Merge remote-tracking branch 'newfsmgen_finalize'

Conflicts:
	plugins/org.eclipse.etrice.ui.behavior.fsm/META-INF/MANIFEST.MF
	plugins/org.eclipse.etrice.ui.behavior/META-INF/MANIFEST.MF

Change-Id: Icc81a851cdcdb35081b8eaa3d5b025c1f850de54

394 files changed, 37476 insertions, 29884 deletions

diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.abstractexec.behavior/META-INF/MANIFEST.MF
index 2981dd2a4..751e56e03 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/META-INF/MANIFEST.MF
@@ -10,7 +10,8 @@ Require-Bundle: org.eclipse.etrice.core.fsm;bundle-version="1.1.3",
  org.eclipse.etrice.generator.fsm;bundle-version="1.1.3",
  org.eclipse.emf.ecore;bundle-version="2.7.0",
  org.eclipse.xtext;bundle-version="2.6.0",
- org.eclipse.core.runtime
+ org.eclipse.core.runtime,
+ org.eclipse.xtext.xbase.lib
 Bundle-Activator: org.eclipse.etrice.abstractexec.behavior.Activator
 Bundle-ActivationPolicy: lazy
 Export-Package: org.eclipse.etrice.abstractexec.behavior,
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/AbstractExecutionValidator.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/AbstractExecutionValidator.java
index 843f948bc..278d1d7bf 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/AbstractExecutionValidator.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/AbstractExecutionValidator.java
@@ -18,9 +18,9 @@ import java.util.List;
 import java.util.Set;
 
 import org.eclipse.core.runtime.Platform;
-import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionRuntimeModule;
 import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionUtil;
 import org.eclipse.etrice.core.common.validation.ICustomValidator;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
@@ -29,16 +29,22 @@ import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
 import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
 import org.eclipse.etrice.core.fsm.fSM.Trigger;
 import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullDiagnostician;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullLogger;
-import org.eclipse.etrice.core.genmodel.fsm.builder.FSMGeneratorModelBuilder;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.NullDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 import org.eclipse.xtext.validation.ValidationMessageAcceptor;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
 
 /**
  * @author rentzhnr
@@ -78,7 +84,7 @@ public class AbstractExecutionValidator implements ICustomValidator {
 		if (!(object instanceof ModelComponent))
 			return;
 		
-		if(context.isGeneration())
+		if (context.isGeneration())
 			return;
 		
 		ModelComponent mc = (ModelComponent) object;
@@ -111,46 +117,42 @@ public class AbstractExecutionValidator implements ICustomValidator {
 		}
 		if (oneProtocolsWithSemantics) {
 			// begin abstract execution on state machine of expanded actor class
-			if (traceExec)
+			if (traceExec) {
 				System.out.println("  Reached where at least one interface items has semantics");
+			}
+			Injector injector = Guice.createInjector(new AbstractExecutionRuntimeModule());
 			NullDiagnostician diagnostician = new NullDiagnostician();
-			FSMGeneratorModelBuilder builder = new FSMGeneratorModelBuilder(
-					new NullLogger(), diagnostician);
-			ExpandedModelComponent xpac;
+			ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(injector, diagnostician);
+			GraphContainer gc;
 			try {
-				xpac = builder.createExpandedModelComponent(mc);
+				gc = builder.createTransformedModel(mc);
+				builder.withTriggersInStates(gc);
 			}
 			catch (Throwable t) {
 				return;
 			}
 
-			if (xpac != null && !diagnostician.isFailed()) {
-				SemanticsCheck checker = new SemanticsCheck(xpac);
+			if (gc != null && gc.getGraph()!=null && !diagnostician.isFailed()) {
+				SemanticsCheck checker = new SemanticsCheck(gc);
 				checker.checkSemantics();
 
 				if (traceExec)
 					System.out.println("  Rule checking for "
-							+ xpac.getModelComponent().getComponentName() + " is over");
+							+ mc.getComponentName() + " is over");
 
-				TreeIterator<EObject> it = xpac.getStateMachine()
-						.eAllContents();
-				while (it.hasNext()) {
-					EObject obj = it.next();
-					if (obj instanceof State) {
-						ProposalGenerator propGen = new ProposalGenerator(xpac,
-								checker);
-						State st = (State) obj;
-						propGen.createProposals(st);
-						createMarkersForProposals(propGen, messageAcceptor, st,
-								xpac);
-					}
-					// the following part takes care of all the warnings
-					if (obj instanceof StateGraphItem) {
-						StateGraphItem item = (StateGraphItem) obj;
-						createMarkersForWarnings(checker, messageAcceptor,
-								item, xpac);
+				for (Node node : IteratorExtensions.toList(FsmGenExtensions.getAllNodes(gc.getGraph()))) {
+					if (node.getStateGraphNode() instanceof State) {
+						ProposalGenerator propGen = new ProposalGenerator(checker);
+						propGen.createProposals(node);
+						createMarkersForProposals(propGen, messageAcceptor, node, gc);
 					}
 				}
+				
+				// the following part takes care of all the warnings
+				for (Link link : IteratorExtensions.toList(FsmGenExtensions.getAllLinks(gc.getGraph()))) {
+					createMarkersForWarnings(checker, messageAcceptor, link, gc);
+				}
+				
 				if (traceExec)
 					System.out
 							.println("AbstractExecutionValidator done checking class "
@@ -178,10 +180,11 @@ public class AbstractExecutionValidator implements ICustomValidator {
 	}
 
 	private void createMarkersForProposals(ProposalGenerator propGen,
-			ValidationMessageAcceptor messageAcceptor, State st,
-			ExpandedModelComponent xpac) {
+			ValidationMessageAcceptor messageAcceptor, Node node,
+			GraphContainer gc) {
 		List<MessageFromIf> incoming = propGen.getIncomingProposals();
-		EObject orig = xpac.getOrig(st);
+		String name = FsmGenExtensions.getName(node);
+		EObject orig = node.getStateGraphNode();
 		EObject container = orig.eContainer();
 		@SuppressWarnings("unchecked")
 		int idx = ((List<? extends EObject>) container.eGet(orig
@@ -191,8 +194,8 @@ public class AbstractExecutionValidator implements ICustomValidator {
 			messageAcceptor.acceptWarning("State should handle the message "
 					+ fsmNameProvider.getMessageName(msg.getMessage()) + " from port "
 					+ msg.getFrom().getName() + " ", container, orig
-					.eContainingFeature(), idx, DIAG_CODE_MISSING_TRIGGER, st
-					.getName(), fsmNameProvider.getMessageName(msg.getMessage()), msg.getFrom()
+					.eContainingFeature(), idx, DIAG_CODE_MISSING_TRIGGER, name,
+					fsmNameProvider.getMessageName(msg.getMessage()), msg.getFrom()
 					.getName());
 		}
 		List<MessageFromIf> outgoing = propGen.getOutgoingProposals();
@@ -201,31 +204,29 @@ public class AbstractExecutionValidator implements ICustomValidator {
 			messageAcceptor.acceptInfo("State should send the message "
 					+ fsmNameProvider.getMessageName(msg.getMessage()) + " to port "
 					+ msg.getFrom().getName() + " ", container, orig
-					.eContainingFeature(), idx, DIAG_CODE_MISSING_MESSAGESEND,
-					st.getName(), fsmNameProvider.getMessageName(msg.getMessage()), msg.getFrom()
+					.eContainingFeature(), idx, DIAG_CODE_MISSING_MESSAGESEND, name,
+					fsmNameProvider.getMessageName(msg.getMessage()), msg.getFrom()
 							.getName());
 		}
 
 	}
 
 	private void createMarkersForWarnings(SemanticsCheck checker,
-			ValidationMessageAcceptor messageAcceptor, StateGraphItem item,
-			ExpandedModelComponent xpac) {
+			ValidationMessageAcceptor messageAcceptor, GraphItem item,
+			GraphContainer gc) {
 		List<HandledMessage> warningList = checker.getWarningMsg(item);
 		if (traceExec && warningList != null) {
+			String name = FsmGenExtensions.getName(item);
 			System.out.println("Messages in the warning list for item "
-					+ item.getName());
+					+ name);
 		}
 		if (warningList != null)
 			for (HandledMessage msg : warningList) {
 				EObject origin = msg.getOrigin();
-				if (origin instanceof ActiveTrigger) {
-					ActiveTrigger trigger = (ActiveTrigger) origin;
-					for (TriggeredTransition trans : trigger.getTransitions()) {
-						// have to translate back the transition to our original
-						// model
-						TriggeredTransition orig = (TriggeredTransition) xpac
-								.getOrig(trans);
+				if (origin instanceof CommonTrigger) {
+					CommonTrigger trigger = (CommonTrigger) origin;
+					for (Link trans : trigger.getLinks()) {
+						TriggeredTransition orig = (TriggeredTransition) trans.getTransition();
 						for (Trigger trig : orig.getTriggers()) {
 							for (MessageFromIf mif : trig.getMsgFromIfPairs()) {
 								// messages haven't been copied, so all point to
@@ -233,12 +234,16 @@ public class AbstractExecutionValidator implements ICustomValidator {
 								// pointers
 								if (mif.getMessage() == msg.getMsg()
 										&& mif.getFrom() == msg.getIfitem()) {
+									String txt = "The message violates the semantic rule";
+									if (msg.getReason()!=null) {
+										txt += "\n" + msg.getReason();
+									}
 									messageAcceptor
 											.acceptWarning(
-													"The message violates the semantic rule",
+													txt,
 													trig,
 													mif.eContainingFeature(),
-													trig.getMsgFromIfPairs().indexOf(trig),
+													trig.getMsgFromIfPairs().indexOf(mif),
 													DIAG_CODE_VIOLATION_TRIGGER,
 													fsmNameProvider.getMessageName(trigger.getMsg()),
 													fsmNameProvider.getMessageName(mif.getMessage()),
@@ -249,10 +254,13 @@ public class AbstractExecutionValidator implements ICustomValidator {
 					}
 				} else if (origin instanceof DetailCode) {
 					DetailCode dc = (DetailCode) origin;
-					EObject orig = xpac.getOrig(dc);
+					String txt = "The message violates the semantic rule";
+					if (msg.getReason()!=null) {
+						txt += "\n" + msg.getReason();
+					}
 					messageAcceptor.acceptWarning(
-							"The message violates the semantic rule",
-							orig.eContainer(), orig.eContainingFeature(),
+							txt,
+							dc.eContainer(), dc.eContainingFeature(),
 							ValidationMessageAcceptor.INSIGNIFICANT_INDEX,
 							DIAG_CODE_VIOLATION_MESSAGESEND,
 							fsmNameProvider.getMessageName(msg.getMsg()),
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActionCodeAnalyzer.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActionCodeAnalyzer.java
index 538aa3374..ca742c5c0 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActionCodeAnalyzer.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActionCodeAnalyzer.java
@@ -32,16 +32,16 @@ public class ActionCodeAnalyzer {
 		
 		private ArrayList<HandledMessage> mifs = new ArrayList<HandledMessage>();
 		
-		public ArrayList<HandledMessage> getMifs() {
+		public List<HandledMessage> getMifs() {
 			return mifs;
 		}
 
 		/* (non-Javadoc)
-		 * @see org.eclipse.etrice.generator.base.DefaultTranslationProvider#getInterfaceItemMessageText(org.eclipse.etrice.core.room.InterfaceItem, org.eclipse.etrice.core.room.Message, java.util.ArrayList, java.lang.String, java.lang.String)
+		 * @see org.eclipse.etrice.generator.base.DefaultTranslationProvider#getInterfaceItemMessageText(org.eclipse.etrice.core.room.InterfaceItem, org.eclipse.etrice.core.room.Message, java.util.List, java.lang.String, java.lang.String)
 		 */
 		@Override
 		public String getInterfaceItemMessageText(AbstractInterfaceItem item,
-				EObject msg, ArrayList<String> args, String index, String orig) {
+				EObject msg, List<String> args, String index, String orig) {
 			
 			HandledMessage sm = new HandledMessage(item, msg, origin);
 			mifs.add(sm);
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActiveRules.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActiveRules.java
index b52e7c569..ae24d6243 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActiveRules.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ActiveRules.java
@@ -19,18 +19,20 @@ import java.util.Map.Entry;
 import java.util.Set;
 
 import org.eclipse.core.runtime.Platform;
+import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.InSemanticsRule;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.ProtocolSemantics;
 import org.eclipse.etrice.core.fsm.fSM.SemanticsRule;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
 
 public class ActiveRules {
 	private HashMap<AbstractInterfaceItem, List<SemanticsRule>> rules;
 	private static boolean traceRules = false;
 	private static int traceLevel = 0;
 	private FSMNameProvider fsmNameProvider = new FSMNameProvider();
+	private EAttribute nameAttribute = null;
 	
 	// HOWTO: use debug options to configure tracing (see also the .options file in the plug-in)
 	static {
@@ -52,11 +54,25 @@ public class ActiveRules {
 	private static final int TRACE_DETAILS = 2;
 
 	public ActiveRules() {
-		rules = new HashMap<AbstractInterfaceItem, List<SemanticsRule>>();
+		this(new HashMap<AbstractInterfaceItem, List<SemanticsRule>>());
 	}
 
 	private ActiveRules(HashMap<AbstractInterfaceItem, List<SemanticsRule>> r) {
 		rules = r;
+		
+		// determine the name attribute of our abstract message
+		if (!rules.isEmpty()) {
+			List<SemanticsRule> ruleList = rules.values().iterator().next();
+			if (!ruleList.isEmpty()) {
+				SemanticsRule rule = ruleList.get(0);
+				for (EAttribute att : rule.getMsg().eClass().getEAllAttributes()) {
+					if (att.getName().equals("name")) {
+						nameAttribute = att;
+						break;
+					}
+				}
+			}
+		}
 	}
 
 	public Set<AbstractInterfaceItem> getPortList() {
@@ -102,7 +118,15 @@ public class ActiveRules {
 					}
 					
 				} else {
-					// TODO: issue a warning?
+					StringBuilder sb = new StringBuilder("Valid messages at this point:");
+					for (SemanticsRule rule : localRules) {
+						String name = rule.getMsg().toString();
+						if (nameAttribute!=null) {
+							name = (String) rule.getMsg().eGet(nameAttribute);
+						}
+						sb.append("\n"+ name);
+					}
+					msg.setReason(sb.toString());
 					wrongMsgList.add(msg);
 				}
 			}
@@ -146,10 +170,8 @@ public class ActiveRules {
 		return new ActiveRules(newRules);
 	}
 
-	public void buildInitLocalRules(ExpandedModelComponent xpAct) {
-		// HashMap<AbstractInterfaceItem, EList<SemanticsRule>> locals = new
-		// HashMap<AbstractInterfaceItem, EList<SemanticsRule>>();
-		List<AbstractInterfaceItem> portList = xpAct.getModelComponent().getAllAbstractInterfaceItems();
+	public void buildInitLocalRules(ModelComponent mc) {
+		List<AbstractInterfaceItem> portList = mc.getAllAbstractInterfaceItems();
 		for (AbstractInterfaceItem ifitem : portList) {
 			if (ifitem.getSemantics()!=null) {
 				rules.put(ifitem, new ArrayList<SemanticsRule>(ifitem.getSemantics().getRules()));
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/HandledMessage.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/HandledMessage.java
index f793f0fe6..6982b28f7 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/HandledMessage.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/HandledMessage.java
@@ -20,6 +20,7 @@ public class HandledMessage {
 	private AbstractInterfaceItem ifitem;
 	private EObject msg;
 	private EObject origin;
+	private String reason;
 
 	public HandledMessage(AbstractInterfaceItem ifitem, EObject msg, EObject origin) {
 		this.ifitem = ifitem;
@@ -38,4 +39,12 @@ public class HandledMessage {
 	public EObject getOrigin() {
 		return origin;
 	}
+
+	public String getReason() {
+		return reason;
+	}
+
+	public void setReason(String reason) {
+		this.reason = reason;
+	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ProposalGenerator.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ProposalGenerator.java
index 47a786eb7..a56229b1c 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ProposalGenerator.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ProposalGenerator.java
@@ -19,18 +19,16 @@ import java.util.Set;
 
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionUtil;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
 import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.SemanticsRule;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 
 public class ProposalGenerator {
-	private ExpandedModelComponent xpac;
 	private SemanticsCheck checker;
 	private List<MessageFromIf> outgoingProposal = new LinkedList<MessageFromIf>();
 	private List<MessageFromIf> incomingProposal = new LinkedList<MessageFromIf>();
@@ -47,9 +45,8 @@ public class ProposalGenerator {
 		}
 	}
 
-	public ProposalGenerator(ExpandedModelComponent xp, SemanticsCheck chk) {
-		xpac = xp;
-		checker = chk;
+	public ProposalGenerator(SemanticsCheck chk) {
+		this.checker = chk;
 	}
 
 	public List<MessageFromIf> getIncomingProposals() {
@@ -60,32 +57,34 @@ public class ProposalGenerator {
 		return outgoingProposal;
 	}
 
-	public void createProposals(State st) {
-		ActiveRules rules = checker.getActiveRules(st);
+	public void createProposals(Node node) {
+		ActiveRules rules = checker.getActiveRules(node);
 
 		// in case the state is disconnected component of the graph
 		if (rules == null)
 			return;
 
 		// ignore substates
-		if (AbstractExecutionUtil.getInstance().getRoomHelpers().hasDirectSubStructure(st))
+		if (node.getSubgraph()!=null)
 			return;
 
 		outgoingProposal.clear();
 		incomingProposal.clear();
 
 		for (AbstractInterfaceItem port : rules.getPortList()) {
-			// collect all messages from active triggers
+			// collect all messages from caught triggers
 			Set<EObject> messages = new HashSet<EObject>();
-			for (ActiveTrigger t : xpac.getActiveTriggers(st))
-				if (t.getIfitem().equals(port))
+			for (CommonTrigger t : node.getCaughtTriggers()) {
+				if (t.getIfitem().equals(port)) {
 					messages.add((EObject)t.getMsg());
+				}
+			}
+			
 			// check if every rule has its messages
 			if (rules.getPortList().contains(port)) {
 				for (SemanticsRule curRule : rules.getRulesForPort(port)) {
 					if (!messages.contains(curRule.getMsg())) {
-						MessageFromIf mif = FSMFactory.eINSTANCE
-								.createMessageFromIf();
+						MessageFromIf mif = FSMFactory.eINSTANCE.createMessageFromIf();
 						mif.setFrom(port);
 						mif.setMessage(curRule.getMsg());
 						boolean isOutgoing = port.getAllOutgoingAbstractMessages().contains(curRule.getMsg());
@@ -100,7 +99,7 @@ public class ProposalGenerator {
 		}
 
 		if (traceProposals) {
-			System.out.println("  Proposals for : " + st.getName());
+			System.out.println("  Proposals for : " + FsmGenExtensions.getName(node));
 
 			for (MessageFromIf msg : outgoingProposal) {
 				System.out.println("    Outgoing msg proposal : "
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityCheck.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityCheck.java
index 9168880c0..9ec094674 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityCheck.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityCheck.java
@@ -17,52 +17,42 @@ import java.util.LinkedList;
 import java.util.Queue;
 import java.util.Set;
 
-import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionUtil;
 import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
 import org.eclipse.etrice.core.fsm.fSM.GuardedTransition;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.generator.fsm.generic.FSMExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 
 public class ReachabilityCheck {
 	
-	private static FSMExtensions fsmExt;
+	private GraphContainer gc;
 	
-	Queue<StateGraphNode> queue;
-	public Set<StateGraphItem> visited;
-	private Set<State> visitedSubStates;
-	private ExpandedModelComponent xpAct;
-	//private Set<StateGraphItem> exitUsed;
+	Queue<Node> queue = new LinkedList<Node>();
+	public Set<GraphItem> visited = new HashSet<GraphItem>();
+	private Set<Node> visitedSubStates = new HashSet<Node>();
 
-	public ReachabilityCheck(ExpandedModelComponent xpac) {
-		fsmExt = new FSMExtensions();
-		queue = new LinkedList<StateGraphNode>();
-		xpAct = xpac;
-		visited = new HashSet<StateGraphItem>();
-		visitedSubStates = new HashSet<State>();
-		//exitUsed = new HashSet<StateGraphItem>();
+	public ReachabilityCheck(GraphContainer gc) {
+		this.gc = gc;
 	}
 
 	public void computeReachability() {
-		StateGraph graph = xpAct.getStateMachine();
-		addStartingPoints(graph, true);
+		addStartingPoints(gc.getGraph(), true);
 		doTraversal();
 		visited.addAll(visitedSubStates);
 	}
 
-	private void addStartingPoints(StateGraph graph, boolean add_initial) {
+	private void addStartingPoints(Graph graph, boolean add_initial) {
 		if (add_initial)
-			for (Transition trans : graph.getTransitions())
-				if (trans instanceof InitialTransition) {
-					visited.add(trans);
-					StateGraphNode cur = AbstractExecutionUtil.getInstance().getRoomHelpers().getNode(trans.getTo());
+			for (Link link : graph.getLinks())
+				if (link.getTransition() instanceof InitialTransition) {
+					visited.add(link);
+					Node cur = link.getTarget();
 					if (!visited.contains(cur))
 						queue.add(cur);
 					break;
@@ -71,55 +61,49 @@ public class ReachabilityCheck {
 
 	private void doTraversal() {
 		while (!queue.isEmpty()) {
-			StateGraphNode node = queue.poll();
-			if (!visited.contains(node))
+			Node node = queue.poll();
+			if (!visited.contains(node)) {
 				visit(node);
-			// System.out.println("Visited node : " + node.getName());
+			}
 		}
 	}
 
-//	public boolean isExitUsed(StateGraphItem item) {
-//		return exitUsed.contains(item);
-//	}
-
-	public boolean isReachable(StateGraphItem item) {
-
+	public boolean isReachable(GraphItem item) {
 		return visited.contains(item);
 	}
 
-	private void visit(StateGraphNode node) {
+	private void visit(Node node) {
 		visited.add(node);
-		if (node instanceof State) {
-			State st = (State) node;
-			if (AbstractExecutionUtil.getInstance().getRoomHelpers().hasDirectSubStructure(st)) {
-				addStartingPoints(st.getSubgraph(), true);
+		if (node.getStateGraphNode() instanceof State) {
+			if (node.getSubgraph()!=null) {
+				addStartingPoints(node.getSubgraph(), true);
 			} else {
 				// visit outgoing triggered transitions
-				for (ActiveTrigger trigger : xpAct.getActiveTriggers(st)) {
-					for (TriggeredTransition trans : trigger.getTransitions())
-						visit(trans);
+				for (CommonTrigger trigger : node.getCaughtTriggers()) {
+					for (Link link : trigger.getLinks())
+						visit(link);
 				}
 				// visit outgoing guarded transitions
-				for(Transition trans : fsmExt.getOutgoingTransitionsHierarchical(xpAct, st)){
-					if(trans instanceof GuardedTransition)
-						visit(trans);
+				for(Link link : FsmGenExtensions.getOutgoingLinksHierarchically(node)){
+					if (link.getTransition() instanceof GuardedTransition)
+						visit(link);
 				}
 			}
 		} else {
-			if (node instanceof EntryPoint) {
+			if (node.getStateGraphNode() instanceof EntryPoint) {
 				// don't set container visited. otherwise its initial transition could not be visited any more
-				State container = (State) node.eContainer().eContainer();
+				Node container = FsmGenExtensions.getParentState(node);
 				visitedSubStates.add(container);
 			}
-			for (Transition trans : xpAct.getOutgoingTransitions(node))
-				visit(trans);
+			for (Link link : node.getOutgoing())
+				visit(link);
 		}
 
 	}
 	
-	private void visit(Transition trans){
-		visited.add(trans);
-		StateGraphNode target = AbstractExecutionUtil.getInstance().getRoomHelpers().getNode(trans.getTo());
+	private void visit(Link link){
+		visited.add(link);
+		Node target = link.getTarget();
 		if (!visited.contains(target))
 			queue.add(target);
 	}
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityValidator.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityValidator.java
index 0ef6c64a6..f575cca20 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityValidator.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/ReachabilityValidator.java
@@ -21,17 +21,25 @@ import java.util.Set;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionRuntimeModule;
 import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionUtil;
 import org.eclipse.etrice.core.common.validation.ICustomValidator;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullDiagnostician;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullLogger;
-import org.eclipse.etrice.core.genmodel.fsm.builder.FSMGeneratorModelBuilder;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.NullDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 import org.eclipse.xtext.validation.ValidationMessageAcceptor;
 
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
 
 public class ReachabilityValidator implements ICustomValidator {
 
@@ -60,38 +68,47 @@ public class ReachabilityValidator implements ICustomValidator {
 			// is checked elsewhere
 			return;
 
+		Injector injector = Guice.createInjector(new AbstractExecutionRuntimeModule());
 		NullDiagnostician diagnostician = new NullDiagnostician();
-		FSMGeneratorModelBuilder builder = new FSMGeneratorModelBuilder(new NullLogger(), diagnostician);
-		ExpandedModelComponent xpac = null;
+		ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(injector, diagnostician);
+		GraphContainer gc;
 		try {
-			xpac = builder.createExpandedModelComponent(mc);
+			gc = builder.createTransformedModel(mc);
+			NullLogger logger = new NullLogger();
+			FsmGenChecker.check(gc, logger);
+			if (logger.hasErrors()) {
+				return;
+			}
+			builder.withTriggersInStates(gc);
 		}
 		catch (Throwable t) {
 			return;
 		}
 		
-		if (xpac != null && !diagnostician.isFailed()) {
-			ReachabilityCheck checker = new ReachabilityCheck(xpac);
+		if (gc != null && gc.getGraph()!=null && !diagnostician.isFailed()) {
+			ReachabilityCheck checker = new ReachabilityCheck(gc);
 			checker.computeReachability();
-			TreeIterator<EObject> it = xpac.getStateMachine().eAllContents();
+			TreeIterator<EObject> it = gc.eAllContents();
 			while (it.hasNext()) {
 				EObject item = it.next();
-				if (item instanceof StateGraphItem)
+				if (item instanceof GraphItem)
 				{
-					StateGraphItem toCheck = (StateGraphItem) item;
+					GraphItem toCheck = (GraphItem) item;
 					if (!checker.isReachable(toCheck)) {
-						EObject orig = xpac.getOrig(toCheck);
-						if (toCheck.getName()==null)
-							// we cannot create an error message
-							continue;
-						
-						EObject container = orig.eContainer();
+						String name = FsmGenExtensions.getName(toCheck);
+						if (name==null) {
+							name = "<no name>";
+						}
+						EObject stateGraphItem = (toCheck instanceof Node) ?
+								((Node) toCheck).getStateGraphNode() : ((Link) toCheck).getTransition();
+								
+						EObject container = stateGraphItem.eContainer();
 						@SuppressWarnings("unchecked")
-						int idx = ((List<? extends EObject>)container.eGet(orig.eContainingFeature())).indexOf(orig);
+						int idx = ((List<? extends EObject>)container.eGet(stateGraphItem.eContainingFeature())).indexOf(stateGraphItem);
 						messageAcceptor.acceptWarning(
 								"Unreachable state/point of graph",
-								xpac.getOrig(toCheck).eContainer(), xpac.getOrig(toCheck).eContainingFeature(), idx,
-								DIAG_CODE_UNREACHABLE, toCheck.getName());
+								stateGraphItem.eContainer(), stateGraphItem.eContainingFeature(), idx,
+								DIAG_CODE_UNREACHABLE, name);
 					}
 				}
 			}
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/SemanticsCheck.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/SemanticsCheck.java
index 4ff24f855..70d8063f8 100644
--- a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/SemanticsCheck.java
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/SemanticsCheck.java
@@ -21,25 +21,25 @@ import java.util.Queue;
 import java.util.Set;
 
 import org.eclipse.core.runtime.Platform;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.etrice.abstractexec.behavior.util.AbstractExecutionUtil;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 
 public class SemanticsCheck {
-	private Queue<StateGraphNode> queue;
-	private Set<StateGraphNode> visited;
-	private ExpandedModelComponent xpAct;
-	private HashMap<StateGraphItem, ActiveRules> mapToRules = new HashMap<StateGraphItem, ActiveRules>();
+	private GraphContainer gc;
+	private Queue<Node> queue = new LinkedList<Node>();
+	private Set<Node> visited = new HashSet<Node>();;
+	private HashMap<GraphItem, ActiveRules> mapToRules = new HashMap<GraphItem, ActiveRules>();
 	private ActionCodeAnalyzer codeAnalyzer;
-	private HashMap<StateGraphItem, List<HandledMessage>> mapToWarnings = new HashMap<StateGraphItem, List<HandledMessage>>();
+	private HashMap<GraphItem, List<HandledMessage>> mapToWarnings = new HashMap<GraphItem, List<HandledMessage>>();
 	private FSMNameProvider fsmNameProvider = new FSMNameProvider();
 	
 	private static boolean traceChecks = false;
@@ -60,51 +60,52 @@ public class SemanticsCheck {
 	private static final int TRACE_RESULT = 1;
 	private static final int TRACE_DETAILS = 2;
 	
-	public SemanticsCheck(ExpandedModelComponent xpac) {
-		queue = new LinkedList<StateGraphNode>();
-		xpAct = xpac;
-		visited = new HashSet<StateGraphNode>();
-		codeAnalyzer = new ActionCodeAnalyzer(xpac.getModelComponent());
+	public SemanticsCheck(GraphContainer gc) {
+		this.gc = gc;
+		this.codeAnalyzer = new ActionCodeAnalyzer(gc.getComponent());
 	}
 
 	public void checkSemantics() {
-		if (traceChecks)
-			System.out.println("checkSemantics: check of ActorClass "+xpAct.getModelComponent().getComponentName());
+		if (traceChecks) {
+			System.out.println("checkSemantics: check of ActorClass "+gc.getComponent().getComponentName());
+		}
 		
-		StateGraph graph = xpAct.getStateMachine();
 		ActiveRules localRules = new ActiveRules();
-		localRules.buildInitLocalRules(xpAct);
-		addStartingPoints(graph, localRules);
+		localRules.buildInitLocalRules(gc.getComponent());
+		addStartingPoints(gc.getGraph(), localRules);
 		doTraversal();
 		
 		if (traceChecks) {
-			if (traceLevel>=TRACE_RESULT)
+			if (traceLevel>=TRACE_RESULT) {
 				printRules();
+			}
 			
-			System.out.println("checkSemantics: done with check of ActorClass "+xpAct.getModelComponent().getComponentName());
+			System.out.println("checkSemantics: done with check of ActorClass "+gc.getComponent().getComponentName());
 		}
 	}
 
-	private void addStartingPoints(StateGraph graph, ActiveRules localRules) {
-		EList<Transition> transitions = graph.getTransitions();
-		for (Transition trans : transitions)
-			if (trans instanceof InitialTransition) {
-				StateGraphNode cur = AbstractExecutionUtil.getInstance().getRoomHelpers().getNode(trans.getTo());
-				List<HandledMessage> msgList = codeAnalyzer.analyze(trans.getAction());
-				if (cur instanceof State) {
-					msgList.addAll(codeAnalyzer.analyze(((State) cur).getEntryCode()));
+	private void addStartingPoints(Graph graph, ActiveRules localRules) {
+		List<Link> links = graph.getLinks();
+		for (Link link : links)
+			if (link.getTransition() instanceof InitialTransition) {
+				Node cur = link.getTarget();
+				List<HandledMessage> msgList = codeAnalyzer.analyze(link.getTransition().getAction());
+				if (cur.getStateGraphNode() instanceof State) {
+					msgList.addAll(codeAnalyzer.analyze(((State) cur.getStateGraphNode()).getEntryCode()));
 				}
 				List<HandledMessage> wrongMsgList = localRules.consumeMessages(msgList);
-				addToWarning(trans, wrongMsgList);
+				if (!wrongMsgList.isEmpty()) {
+					addToWarning(link, wrongMsgList);
+				}
 				boolean rulesChanged = false;
 				if (mapToRules.containsKey(cur)) {
 					rulesChanged = mapToRules.get(cur).merge(localRules);
 				} else {
-					mapToRules.put(cur, localRules);
+					mapToRules.put(link.getTarget(), localRules);
 					rulesChanged = true;
 				}
-				if (!visited.contains(cur) || rulesChanged)
-					queue.add(cur);
+				if (!visited.contains(link.getTarget()) || rulesChanged)
+					queue.add(link.getTarget());
 
 				break;
 			}
@@ -112,31 +113,31 @@ public class SemanticsCheck {
 
 	private void doTraversal() {
 		while (!queue.isEmpty()) {
-			Visit(queue.poll());
+			visit(queue.poll());
 		}
 	}
 
-	private void Visit(StateGraphNode node) {
+	private void visit(Node node) {
 		visited.add(node);
-		if (node instanceof State) {
-			State st = (State) node;
-			if (AbstractExecutionUtil.getInstance().getRoomHelpers().hasDirectSubStructure(st)) {
-				addStartingPoints(st.getSubgraph(), mapToRules.get(st));
+		if (node.getStateGraphNode() instanceof State) {
+			State st = (State) node.getStateGraphNode();
+			if (node.getSubgraph()!=null) {
+				addStartingPoints(node.getSubgraph(), mapToRules.get(node));
 			}
 			else {
-				for (ActiveTrigger trigger : xpAct.getActiveTriggers(st)) {
+				for (CommonTrigger trigger : node.getCaughtTriggers()) {
 					if (traceChecks && traceLevel>=TRACE_DETAILS) {
 						System.out.println("  Currently visiting: " + st.getName());
 						System.out.println("  Trigger: " + fsmNameProvider.getMessageName(trigger.getMsg()));
 					}
 					
-					for (Transition trans : trigger.getTransitions()) {
-						StateGraphNode target = AbstractExecutionUtil.getInstance().getRoomHelpers().getNode(trans.getTo());
+					for (Link link : trigger.getLinks()) {
+						Node target = link.getTarget();
 						List<HandledMessage> msgList = new LinkedList<HandledMessage>();
 						// create a list of codes here in the order
 						// trigger, exit, action, entry
 						msgList.add(new HandledMessage(trigger.getIfitem(), trigger.getMsg(), trigger));
-						StateGraph triggerContext = (StateGraph) trans.eContainer();
+						StateGraph triggerContext = link.getGraph().getStateGraph();
 						State exitCalled = st;
 						while (true) {
 							// this is where all the exit code is added
@@ -145,9 +146,9 @@ public class SemanticsCheck {
 								break;
 							exitCalled = (State) exitCalled.eContainer().eContainer();
 						}
-						msgList.addAll(codeAnalyzer.analyze(trans.getAction()));
-						if (target instanceof State) {
-							msgList.addAll(codeAnalyzer.analyze(((State) target).getEntryCode()));
+						msgList.addAll(codeAnalyzer.analyze(link.getTransition().getAction()));
+						if (target.getStateGraphNode() instanceof State) {
+							msgList.addAll(codeAnalyzer.analyze(((State) target.getStateGraphNode()).getEntryCode()));
 						}
 						ActiveRules tempRule = mapToRules.get(node).createCopy();
 						
@@ -162,10 +163,13 @@ public class SemanticsCheck {
 							printRules();
 						}
 						List<HandledMessage> wrongMsgList = tempRule.consumeMessages(msgList);
-						addToWarning(node, wrongMsgList);
+						if (!wrongMsgList.isEmpty()) {
+							addToWarning(link, wrongMsgList);
+						}
 															
-						if (traceChecks && traceLevel>=TRACE_DETAILS)
+						if (traceChecks && traceLevel>=TRACE_DETAILS) {
 							System.out.println("  Messages consumed");
+						}
 						
 						addAndMergeRules(target, tempRule);
 						
@@ -181,28 +185,30 @@ public class SemanticsCheck {
 			/*
 			 * If the current node is an Entry/Exit/Transition/Choice pt , then
 			 * only the action code in the outgoing transition needs to be
-			 * considered For this, a copy of the ActiveRules of the current
+			 * considered. For this, a copy of the ActiveRules of the current
 			 * node is created and is checked against each outgoing transition
-			 * for Rule changes If there is any rule change or if the
+			 * for Rule changes. If there is any rule change or if the
 			 * destination state hasn't been visited then the destination rules
 			 * are merged with the current rules and destination node is added
 			 * to the current queue.
 			 */
-			for (Transition trans : xpAct.getOutgoingTransitions(node)) {
+			for (Link link : node.getOutgoing()) {
 				ActiveRules tempRule = mapToRules.get(node).createCopy();
-				List<HandledMessage> msgList = codeAnalyzer.analyze(trans.getAction());
-				StateGraphNode target = AbstractExecutionUtil.getInstance().getRoomHelpers().getNode(trans.getTo());
-				if (target instanceof State) {
-					msgList.addAll(codeAnalyzer.analyze(((State) target).getEntryCode()));
+				List<HandledMessage> msgList = codeAnalyzer.analyze(link.getTransition().getAction());
+				Node target = link.getTarget();
+				if (target.getStateGraphNode() instanceof State) {
+					msgList.addAll(codeAnalyzer.analyze(((State) target.getStateGraphNode()).getEntryCode()));
 				}
 				List<HandledMessage> wrongMsgList = tempRule.consumeMessages(msgList);
-				addToWarning(node, wrongMsgList);
+				if (!wrongMsgList.isEmpty()) {
+					addToWarning(link, wrongMsgList);
+				}
 				addAndMergeRules(target, tempRule);
 			}
 		}
 	}
 
-	private void addToWarning(StateGraphItem item,
+	private void addToWarning(GraphItem item,
 			List<HandledMessage> wrongMsgList) {
 		if (mapToWarnings.containsKey(item)) {
 			mapToWarnings.get(item).addAll(wrongMsgList);
@@ -210,7 +216,7 @@ public class SemanticsCheck {
 			mapToWarnings.put(item, wrongMsgList);
 		}
 	}
-	private void addAndMergeRules(StateGraphNode target, ActiveRules tempRule) {
+	private void addAndMergeRules(Node target, ActiveRules tempRule) {
 		boolean rulesChanged = false;
 		if (mapToRules.containsKey(target)) {
 			rulesChanged = mapToRules.get(target).merge(tempRule);
@@ -227,17 +233,18 @@ public class SemanticsCheck {
 	public void printRules() {
 		System.out.println("  Current Rules: ");
 		System.out.println("    MapToRules size: " + this.mapToRules.size());
-		for (StateGraphItem item : this.mapToRules.keySet()) {
-			System.out.println("    Rules for " + item.getName() + " : ");
+		for (GraphItem item : this.mapToRules.keySet()) {
+			
+			System.out.println("    Rules for " + FsmGenExtensions.getName(item) + " : ");
 			mapToRules.get(item).print();
 		}
 	}
 
-	public ActiveRules getActiveRules(StateGraphItem item) {
+	public ActiveRules getActiveRules(GraphItem item) {
 		return mapToRules.get(item);
 	}
-	public List<HandledMessage> getWarningMsg (StateGraphItem item)
-	{
+	
+	public List<HandledMessage> getWarningMsg (GraphItem item) {
 		return mapToWarnings.get(item);
 	}
 }
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/AbstractExecutionRuntimeModule.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/AbstractExecutionRuntimeModule.java
new file mode 100644
index 000000000..3d5784bca
--- /dev/null
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/AbstractExecutionRuntimeModule.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.abstractexec.behavior.util;
+
+import org.eclipse.etrice.core.fsm.FSMRuntimeModule;
+import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator;
+
+public class AbstractExecutionRuntimeModule extends FSMRuntimeModule {
+	
+    public Class<? extends ICommonDataCalculator> bindICommonDataCalculator() {
+        return DummyDataCalculator.class;
+    }
+
+}
diff --git a/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/DummyDataCalculator.java b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/DummyDataCalculator.java
new file mode 100644
index 000000000..398566a39
--- /dev/null
+++ b/plugins/org.eclipse.etrice.abstractexec.behavior/src/org/eclipse/etrice/abstractexec/behavior/util/DummyDataCalculator.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.abstractexec.behavior.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+
+public class DummyDataCalculator implements ICommonDataCalculator {
+
+	@Override
+	public EObject calculateCommonData(Link l) {
+		return null;
+	}
+
+}
diff --git a/plugins/org.eclipse.etrice.core.common.ui/src/org/eclipse/etrice/core/common/ui/labeling/BaseLabelProvider.xtend b/plugins/org.eclipse.etrice.core.common.ui/src/org/eclipse/etrice/core/common/ui/labeling/BaseLabelProvider.xtend
index fe642034d..61696340b 100644
--- a/plugins/org.eclipse.etrice.core.common.ui/src/org/eclipse/etrice/core/common/ui/labeling/BaseLabelProvider.xtend
+++ b/plugins/org.eclipse.etrice.core.common.ui/src/org/eclipse/etrice/core/common/ui/labeling/BaseLabelProvider.xtend
@@ -47,7 +47,7 @@ class BaseLabelProvider extends org.eclipse.xtext.ui.label.DefaultEObjectLabelPr
 	}
 	
 	def StyledString text(Import im) {
-		if (im.getImportedNamespace() == null) {
+		if (im.getImportedNamespace() === null) {
 			var txt = new StyledString("import model " + im.getImportURI())
 			txt.setStyle(0, 12, getKeywordStyler())
 			return txt
@@ -59,7 +59,7 @@ class BaseLabelProvider extends org.eclipse.xtext.ui.label.DefaultEObjectLabelPr
 	}
 	
 	def protected Styler getKeywordStyler() {
-		if (keywordStyler==null) {
+		if (keywordStyler===null) {
 			var font = JFaceResources.getFontDescriptor(JFaceResources.TEXT_FONT)
 			var boldFont = font.setStyle(SWT.BOLD)
 			keywordStyler = stylerFactory.createStyler(boldFont, KEYWORD_COLOR, null)
@@ -68,7 +68,7 @@ class BaseLabelProvider extends org.eclipse.xtext.ui.label.DefaultEObjectLabelPr
 	}
 
 	def protected Styler getTypeStyler() {
-		if (typeStyler==null) {
+		if (typeStyler===null) {
 			var font = JFaceResources.getFontDescriptor(JFaceResources.TEXT_FONT)
 			var italicFont = font.setStyle(SWT.ITALIC)
 			typeStyler = stylerFactory.createStyler(italicFont, null, null)
diff --git a/plugins/org.eclipse.etrice.core.common/.antlr-generator-3.2.0-patch.jar b/plugins/org.eclipse.etrice.core.common/.antlr-generator-3.2.0-patch.jar
deleted file mode 100644
index 90516fd7a..000000000
--- a/plugins/org.eclipse.etrice.core.common/.antlr-generator-3.2.0-patch.jar
+++ /dev/null
diff --git a/plugins/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/validation/AbstractBaseTestJavaValidator.java b/plugins/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/validation/AbstractBaseTestJavaValidator.java
new file mode 100644
index 000000000..22e4381f0
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/validation/AbstractBaseTestJavaValidator.java
@@ -0,0 +1,20 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.etrice.core.common.validation;
+ 
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EPackage;
+
+public class AbstractBaseTestJavaValidator extends org.eclipse.etrice.core.common.validation.BaseJavaValidator {
+
+	@Override
+	protected List<EPackage> getEPackages() {
+	    List<EPackage> result = new ArrayList<EPackage>();
+	    result.add(org.eclipse.etrice.core.common.basetest.BasetestPackage.eINSTANCE);
+		return result;
+	}
+
+}
diff --git a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/postprocessing/PostprocessingHelpers.xtend b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/postprocessing/PostprocessingHelpers.xtend
index 8da578302..0e8bbfc2a 100644
--- a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/postprocessing/PostprocessingHelpers.xtend
+++ b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/postprocessing/PostprocessingHelpers.xtend
@@ -12,13 +12,13 @@
 
 package org.eclipse.etrice.core.common.postprocessing
 
-import org.eclipse.emf.ecore.EPackage
 import org.eclipse.emf.ecore.EClass
 import org.eclipse.emf.ecore.EClassifier
-import org.eclipse.emf.ecore.EcoreFactory
+import org.eclipse.emf.ecore.EModelElement
+import org.eclipse.emf.ecore.EPackage
 import org.eclipse.emf.ecore.ETypedElement
+import org.eclipse.emf.ecore.EcoreFactory
 import org.eclipse.emf.ecore.util.EcoreUtil
-import org.eclipse.emf.ecore.EModelElement
 
 class PostprocessingHelpers {
 	
@@ -55,7 +55,7 @@ class PostprocessingHelpers {
 		op.setEType(type)
 		op.setUpperBound(upperBound)
 		
-		if (body!=null) {
+		if (body !== null) {
 			val anno = EcoreFactory::eINSTANCE.createEAnnotation
 			anno.setSource("http://www.eclipse.org/emf/2002/GenModel")
 			anno.details.put("body", body)
@@ -65,6 +65,15 @@ class PostprocessingHelpers {
 		owner.EOperations.add(op)
 	}
 	
+	def static addAttribute(EClass owner, String name, EClassifier type, Object defaultValue) {
+		val attr = EcoreFactory::eINSTANCE.createEAttribute
+		attr.setName(name)
+		attr.setEType(type)
+		attr.defaultValue = defaultValue
+		
+		owner.EStructuralFeatures.add(attr)
+	}
+	
 	def static addClass(EPackage pck, String name) {
 		val cls = EcoreFactory::eINSTANCE.createEClass
 		cls.name = name
diff --git a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/scoping/StandardModelLocator.java b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/scoping/StandardModelLocator.java
index c83edc975..87c13207f 100644
--- a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/scoping/StandardModelLocator.java
+++ b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/scoping/StandardModelLocator.java
@@ -60,16 +60,18 @@ public class StandardModelLocator implements IModelLocator {
 		try {
 			URIConverter converter = resource==null? null : resource.getResourceSet().getURIConverter();
 			URI canonical = getCanonicalFileURI(resolve, converter);
-			if (canonical.isPlatform()) {
-				resolve = "platform:/resource" + canonical.toPlatformString(true);
+			// TODO handle non-file URIs more generically
+			if(canonical != null && (canonical.isFile() || canonical.isArchive() || canonical.isPlatform() || canonical.scheme() == "classpath")) {
+				resolve = canonical.toString();
 			}
 			else {
 				resolve = canonical.toFileString();
-
-				resolve = resolve.replaceAll("\\\\", "/");
-				resolve = resolve.replaceAll("//", "/");
-				
-				resolve = URI.createFileURI(resolve).toString();
+				if(resolve != null) {
+					resolve = resolve.replaceAll("\\\\", "/");
+					resolve = resolve.replaceAll("//", "/");
+					
+					resolve = URI.createFileURI(resolve).toString();
+				}
 			}
 		} catch (IOException e) {
 			return null;
@@ -291,17 +293,15 @@ public class StandardModelLocator implements IModelLocator {
 	}
 	
 	private URI getCanonicalFileURI(String uriString, URIConverter uriConverter) throws IOException {
-		URI uri;
-		if (uriString.startsWith(CLASSPATH) || uriString.startsWith("platform:/") || uriString.startsWith("file:/")) {
+		URI uri = null;
+		try {
+			// try valid uri
 			uri = URI.createURI(uriString);
+		} catch(IllegalArgumentException e1) {
 		}
-		else {
-			try {
-				uri = URI.createFileURI(uriString);
-			}
-			catch (IllegalArgumentException e) {
-				throw new IOException();
-			}
+		if(uri == null || !(uri.isFile() || uri.isArchive() || uri.isPlatform() || uri.scheme() == "classpath")) {
+			// try file path
+			uri = URI.createFileURI(uriString);
 		}
 		
 		URI normalized = uri;
diff --git a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/BaseTestJavaValidator.java b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/BaseTestJavaValidator.java
new file mode 100644
index 000000000..d6cf6b653
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/BaseTestJavaValidator.java
@@ -0,0 +1,19 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.etrice.core.common.validation;
+
+/**
+ * This class contains custom validation rules. 
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+public class BaseTestJavaValidator extends BaseJavaValidator {
+
+//	@Check
+//	public void checkGreetingStartsWithCapital(Greeting greeting) {
+//		if (!Character.isUpperCase(greeting.getName().charAt(0))) {
+//			warning("Name should start with a capital", MyDslPackage.Literals.GREETING__NAME);
+//		}
+//	}
+}
diff --git a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/ValidationHelpers.xtend b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/ValidationHelpers.xtend
index b9ec50910..e201f2fb1 100644
--- a/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/ValidationHelpers.xtend
+++ b/plugins/org.eclipse.etrice.core.common/src/org/eclipse/etrice/core/common/validation/ValidationHelpers.xtend
@@ -76,7 +76,7 @@ class ValidationHelpers {
 	def static <E extends EObject> saveRecursiveVisitor(E  start, Function<E , E> function){
 		val Set<E> visited = newHashSet
 		var E next = start
-		while(next != null && !next.eIsProxy && (visited += next))
+		while(next !== null && !next.eIsProxy && (visited += next))
 			next = function.apply(next)
 	}
 }
diff --git a/plugins/org.eclipse.etrice.core.config/src/org/eclipse/etrice/core/validation/ConfigJavaValidator.java b/plugins/org.eclipse.etrice.core.config/src/org/eclipse/etrice/core/validation/ConfigJavaValidator.java
index 164edfa63..69658faaa 100644
--- a/plugins/org.eclipse.etrice.core.config/src/org/eclipse/etrice/core/validation/ConfigJavaValidator.java
+++ b/plugins/org.eclipse.etrice.core.config/src/org/eclipse/etrice/core/validation/ConfigJavaValidator.java
@@ -518,7 +518,7 @@ public class ConfigJavaValidator extends AbstractConfigJavaValidator {
 				ProtocolClass protocol = (ProtocolClass) generalProtocol;
 				for (ProtocolClassConfig cf : model.getProtocolClassConfigs()) {
 					if (cf.getProtocol().equals(protocol)) {
-						if (protocol.getRegular().equals(configUtil.getPortClass(portInstanceConfig)))
+						if (protocol.getRegular()!=null && protocol.getRegular().equals(configUtil.getPortClass(portInstanceConfig)))
 							portClassConfig = cf.getRegular();
 						else
 							portClassConfig = cf.getConjugated();
diff --git a/plugins/org.eclipse.etrice.core.etmap/src/org/eclipse/etrice/core/etmap/util/ETMapUtil.java b/plugins/org.eclipse.etrice.core.etmap/src/org/eclipse/etrice/core/etmap/util/ETMapUtil.java
index 144c3c79f..d454ab6da 100644
--- a/plugins/org.eclipse.etrice.core.etmap/src/org/eclipse/etrice/core/etmap/util/ETMapUtil.java
+++ b/plugins/org.eclipse.etrice.core.etmap/src/org/eclipse/etrice/core/etmap/util/ETMapUtil.java
@@ -38,7 +38,7 @@ import org.eclipse.etrice.core.genmodel.etricegen.Root;
 import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.SystemInstance;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
 import org.eclipse.etrice.core.room.ActorInstanceMapping;
 import org.eclipse.etrice.core.room.LogicalThread;
 import org.eclipse.etrice.core.room.RefPath;
diff --git a/plugins/org.eclipse.etrice.core.etphys/.launch/Generate Language Infrastructure (org.eclipse.etrice.core.etphys).launch b/plugins/org.eclipse.etrice.core.etphys/.launch/Generate Language Infrastructure (org.eclipse.etrice.core.etphys).launch
index c74036855..994bfa4b9 100644
--- a/plugins/org.eclipse.etrice.core.etphys/.launch/Generate Language Infrastructure (org.eclipse.etrice.core.etphys).launch
+++ b/plugins/org.eclipse.etrice.core.etphys/.launch/Generate Language Infrastructure (org.eclipse.etrice.core.etphys).launch
@@ -11,15 +11,12 @@
 <listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
 <listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
 </listAttribute>
-<<<<<<< HEAD
-=======
 <listAttribute key="org.eclipse.jdt.launching.CLASSPATH">
 <listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;runtimeClasspathEntry containerPath=&quot;org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5&quot; javaProject=&quot;org.eclipse.etrice.core.etphys&quot; path=&quot;1&quot; type=&quot;4&quot;/&gt;&#13;&#10;"/>
 <listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;runtimeClasspathEntry id=&quot;org.eclipse.jdt.launching.classpathentry.defaultClasspath&quot;&gt;&#13;&#10;&lt;memento exportedEntriesOnly=&quot;false&quot; project=&quot;org.eclipse.etrice.core.etphys&quot;/&gt;&#13;&#10;&lt;/runtimeClasspathEntry&gt;&#13;&#10;"/>
 <listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;runtimeClasspathEntry internalArchive=&quot;/org.eclipse.etrice.core.room/.antlr-generator-3.2.0.jar&quot; path=&quot;3&quot; type=&quot;2&quot;/&gt;&#13;&#10;"/>
 </listAttribute>
 <booleanAttribute key="org.eclipse.jdt.launching.DEFAULT_CLASSPATH" value="false"/>
->>>>>>> refs/remotes/origin/CGenPhysical
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="src/org/eclipse/etrice/core/etphys/GenerateETPhys.mwe2"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.etphys"/>
diff --git a/plugins/org.eclipse.etrice.core.fsm.ui/plugin.xml b/plugins/org.eclipse.etrice.core.fsm.ui/plugin.xml
index 87f044c39..bef30644d 100644
--- a/plugins/org.eclipse.etrice.core.fsm.ui/plugin.xml
+++ b/plugins/org.eclipse.etrice.core.fsm.ui/plugin.xml
@@ -185,6 +185,7 @@
 			</command>
          </menuContribution>
     </extension>
+    
     <extension point="org.eclipse.ui.menus">
 		<menuContribution locationURI="popup:#TextEditorContext?endof=group.find">
 			<command commandId="org.eclipse.xtext.ui.editor.FindReferences">
diff --git a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSM.g b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSM.g
index 58689239b..c402e4bc7 100644
--- a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSM.g
+++ b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSM.g
@@ -450,6 +450,32 @@ finally {
 
 
 
+// Entry rule entryRuleTransitionBase
+entryRuleTransitionBase 
+:
+{ before(grammarAccess.getTransitionBaseRule()); }
+	 ruleTransitionBase
+{ after(grammarAccess.getTransitionBaseRule()); } 
+	 EOF 
+;
+
+// Rule TransitionBase
+ruleTransitionBase
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTransitionBaseAccess().getAlternatives()); }
+(rule__TransitionBase__Alternatives)
+{ after(grammarAccess.getTransitionBaseAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
 
 
 // Entry rule entryRuleTransition
@@ -1766,6 +1792,27 @@ finally {
 	restoreStackSize(stackSize);
 }
 
+rule__TransitionBase__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); }
+	ruleTransition
+{ after(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); }
+	ruleRefinedTransition
+{ after(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
 
 rule__Transition__Alternatives
     @init {
diff --git a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMLexer.java b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMLexer.java
index 57790fa63..4a3f53d74 100644
--- a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMLexer.java
+++ b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMLexer.java
@@ -1344,10 +1344,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_HEX;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11625:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
-            // InternalFSM.g:11625:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalFSM.g:11672:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalFSM.g:11672:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalFSM.g:11625:12: ( '0x' | '0X' )
+            // InternalFSM.g:11672:12: ( '0x' | '0X' )
             int alt1=2;
             int LA1_0 = input.LA(1);
 
@@ -1375,7 +1375,7 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt1) {
                 case 1 :
-                    // InternalFSM.g:11625:13: '0x'
+                    // InternalFSM.g:11672:13: '0x'
                     {
                     match("0x"); 
 
@@ -1383,7 +1383,7 @@ public class InternalFSMLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:11625:18: '0X'
+                    // InternalFSM.g:11672:18: '0X'
                     {
                     match("0X"); 
 
@@ -1393,7 +1393,7 @@ public class InternalFSMLexer extends Lexer {
 
             }
 
-            // InternalFSM.g:11625:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalFSM.g:11672:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             int cnt2=0;
             loop2:
             do {
@@ -1447,12 +1447,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_CC_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11627:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
-            // InternalFSM.g:11627:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+            // InternalFSM.g:11674:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalFSM.g:11674:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalFSM.g:11627:27: ( options {greedy=false; } : . )*
+            // InternalFSM.g:11674:27: ( options {greedy=false; } : . )*
             loop3:
             do {
                 int alt3=2;
@@ -1486,7 +1486,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt3) {
             	case 1 :
-            	    // InternalFSM.g:11627:55: .
+            	    // InternalFSM.g:11674:55: .
             	    {
             	    matchAny(); 
 
@@ -1516,10 +1516,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ID;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11629:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
-            // InternalFSM.g:11629:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalFSM.g:11676:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalFSM.g:11676:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalFSM.g:11629:11: ( '^' )?
+            // InternalFSM.g:11676:11: ( '^' )?
             int alt4=2;
             int LA4_0 = input.LA(1);
 
@@ -1528,7 +1528,7 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt4) {
                 case 1 :
-                    // InternalFSM.g:11629:11: '^'
+                    // InternalFSM.g:11676:11: '^'
                     {
                     match('^'); 
 
@@ -1546,7 +1546,7 @@ public class InternalFSMLexer extends Lexer {
                 recover(mse);
                 throw mse;}
 
-            // InternalFSM.g:11629:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalFSM.g:11676:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             loop5:
             do {
                 int alt5=2;
@@ -1595,10 +1595,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_INT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11631:10: ( ( '0' .. '9' )+ )
-            // InternalFSM.g:11631:12: ( '0' .. '9' )+
+            // InternalFSM.g:11678:10: ( ( '0' .. '9' )+ )
+            // InternalFSM.g:11678:12: ( '0' .. '9' )+
             {
-            // InternalFSM.g:11631:12: ( '0' .. '9' )+
+            // InternalFSM.g:11678:12: ( '0' .. '9' )+
             int cnt6=0;
             loop6:
             do {
@@ -1612,7 +1612,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt6) {
             	case 1 :
-            	    // InternalFSM.g:11631:13: '0' .. '9'
+            	    // InternalFSM.g:11678:13: '0' .. '9'
             	    {
             	    matchRange('0','9'); 
 
@@ -1644,10 +1644,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11633:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
-            // InternalFSM.g:11633:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalFSM.g:11680:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalFSM.g:11680:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalFSM.g:11633:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalFSM.g:11680:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -1665,10 +1665,10 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalFSM.g:11633:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+                    // InternalFSM.g:11680:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalFSM.g:11633:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalFSM.g:11680:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
                     loop7:
                     do {
                         int alt7=3;
@@ -1684,7 +1684,7 @@ public class InternalFSMLexer extends Lexer {
 
                         switch (alt7) {
                     	case 1 :
-                    	    // InternalFSM.g:11633:21: '\\\\' .
+                    	    // InternalFSM.g:11680:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -1692,7 +1692,7 @@ public class InternalFSMLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalFSM.g:11633:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalFSM.g:11680:28: ~ ( ( '\\\\' | '\"' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -1717,10 +1717,10 @@ public class InternalFSMLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:11633:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
+                    // InternalFSM.g:11680:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalFSM.g:11633:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalFSM.g:11680:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
                     loop8:
                     do {
                         int alt8=3;
@@ -1736,7 +1736,7 @@ public class InternalFSMLexer extends Lexer {
 
                         switch (alt8) {
                     	case 1 :
-                    	    // InternalFSM.g:11633:54: '\\\\' .
+                    	    // InternalFSM.g:11680:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -1744,7 +1744,7 @@ public class InternalFSMLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalFSM.g:11633:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalFSM.g:11680:61: ~ ( ( '\\\\' | '\\'' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -1787,12 +1787,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ML_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11635:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
-            // InternalFSM.g:11635:19: '/*' ( options {greedy=false; } : . )* '*/'
+            // InternalFSM.g:11682:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalFSM.g:11682:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalFSM.g:11635:24: ( options {greedy=false; } : . )*
+            // InternalFSM.g:11682:24: ( options {greedy=false; } : . )*
             loop10:
             do {
                 int alt10=2;
@@ -1817,7 +1817,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt10) {
             	case 1 :
-            	    // InternalFSM.g:11635:52: .
+            	    // InternalFSM.g:11682:52: .
             	    {
             	    matchAny(); 
 
@@ -1847,12 +1847,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_SL_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11637:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
-            // InternalFSM.g:11637:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            // InternalFSM.g:11684:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalFSM.g:11684:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalFSM.g:11637:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalFSM.g:11684:24: (~ ( ( '\\n' | '\\r' ) ) )*
             loop11:
             do {
                 int alt11=2;
@@ -1865,7 +1865,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt11) {
             	case 1 :
-            	    // InternalFSM.g:11637:24: ~ ( ( '\\n' | '\\r' ) )
+            	    // InternalFSM.g:11684:24: ~ ( ( '\\n' | '\\r' ) )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -1885,7 +1885,7 @@ public class InternalFSMLexer extends Lexer {
                 }
             } while (true);
 
-            // InternalFSM.g:11637:40: ( ( '\\r' )? '\\n' )?
+            // InternalFSM.g:11684:40: ( ( '\\r' )? '\\n' )?
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -1894,9 +1894,9 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalFSM.g:11637:41: ( '\\r' )? '\\n'
+                    // InternalFSM.g:11684:41: ( '\\r' )? '\\n'
                     {
-                    // InternalFSM.g:11637:41: ( '\\r' )?
+                    // InternalFSM.g:11684:41: ( '\\r' )?
                     int alt12=2;
                     int LA12_0 = input.LA(1);
 
@@ -1905,7 +1905,7 @@ public class InternalFSMLexer extends Lexer {
                     }
                     switch (alt12) {
                         case 1 :
-                            // InternalFSM.g:11637:41: '\\r'
+                            // InternalFSM.g:11684:41: '\\r'
                             {
                             match('\r'); 
 
@@ -1937,10 +1937,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_WS;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11639:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
-            // InternalFSM.g:11639:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalFSM.g:11686:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalFSM.g:11686:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalFSM.g:11639:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalFSM.g:11686:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             int cnt14=0;
             loop14:
             do {
@@ -1994,8 +1994,8 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ANY_OTHER;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:11641:16: ( . )
-            // InternalFSM.g:11641:18: .
+            // InternalFSM.g:11688:16: ( . )
+            // InternalFSM.g:11688:18: .
             {
             matchAny(); 
 
diff --git a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMParser.java b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMParser.java
index 0626957e0..b7464e966 100644
--- a/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMParser.java
+++ b/plugins/org.eclipse.etrice.core.fsm.ui/src-gen/org/eclipse/etrice/core/fsm/ui/contentassist/antlr/internal/InternalFSMParser.java
@@ -1228,12 +1228,89 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalFSM.g:454:1: entryRuleTransitionBase : ruleTransitionBase EOF ;
+    public final void entryRuleTransitionBase() throws RecognitionException {
+        try {
+            // InternalFSM.g:455:1: ( ruleTransitionBase EOF )
+            // InternalFSM.g:456:1: ruleTransitionBase EOF
+            {
+             before(grammarAccess.getTransitionBaseRule()); 
+            pushFollow(FOLLOW_1);
+            ruleTransitionBase();
+
+            state._fsp--;
+
+             after(grammarAccess.getTransitionBaseRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleTransitionBase"
+
+
+    // $ANTLR start "ruleTransitionBase"
+    // InternalFSM.g:463:1: ruleTransitionBase : ( ( rule__TransitionBase__Alternatives ) ) ;
+    public final void ruleTransitionBase() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalFSM.g:467:2: ( ( ( rule__TransitionBase__Alternatives ) ) )
+            // InternalFSM.g:468:1: ( ( rule__TransitionBase__Alternatives ) )
+            {
+            // InternalFSM.g:468:1: ( ( rule__TransitionBase__Alternatives ) )
+            // InternalFSM.g:469:1: ( rule__TransitionBase__Alternatives )
+            {
+             before(grammarAccess.getTransitionBaseAccess().getAlternatives()); 
+            // InternalFSM.g:470:1: ( rule__TransitionBase__Alternatives )
+            // InternalFSM.g:470:2: rule__TransitionBase__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__TransitionBase__Alternatives();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getTransitionBaseAccess().getAlternatives()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleTransitionBase"
+
+
     // $ANTLR start "entryRuleTransition"
-    // InternalFSM.g:456:1: entryRuleTransition : ruleTransition EOF ;
+    // InternalFSM.g:482:1: entryRuleTransition : ruleTransition EOF ;
     public final void entryRuleTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:457:1: ( ruleTransition EOF )
-            // InternalFSM.g:458:1: ruleTransition EOF
+            // InternalFSM.g:483:1: ( ruleTransition EOF )
+            // InternalFSM.g:484:1: ruleTransition EOF
             {
              before(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1259,21 +1336,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransition"
-    // InternalFSM.g:465:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ;
+    // InternalFSM.g:491:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ;
     public final void ruleTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:469:2: ( ( ( rule__Transition__Alternatives ) ) )
-            // InternalFSM.g:470:1: ( ( rule__Transition__Alternatives ) )
+            // InternalFSM.g:495:2: ( ( ( rule__Transition__Alternatives ) ) )
+            // InternalFSM.g:496:1: ( ( rule__Transition__Alternatives ) )
             {
-            // InternalFSM.g:470:1: ( ( rule__Transition__Alternatives ) )
-            // InternalFSM.g:471:1: ( rule__Transition__Alternatives )
+            // InternalFSM.g:496:1: ( ( rule__Transition__Alternatives ) )
+            // InternalFSM.g:497:1: ( rule__Transition__Alternatives )
             {
              before(grammarAccess.getTransitionAccess().getAlternatives()); 
-            // InternalFSM.g:472:1: ( rule__Transition__Alternatives )
-            // InternalFSM.g:472:2: rule__Transition__Alternatives
+            // InternalFSM.g:498:1: ( rule__Transition__Alternatives )
+            // InternalFSM.g:498:2: rule__Transition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Transition__Alternatives();
@@ -1306,11 +1383,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalFSM.g:484:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ;
+    // InternalFSM.g:510:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ;
     public final void entryRuleNonInitialTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:485:1: ( ruleNonInitialTransition EOF )
-            // InternalFSM.g:486:1: ruleNonInitialTransition EOF
+            // InternalFSM.g:511:1: ( ruleNonInitialTransition EOF )
+            // InternalFSM.g:512:1: ruleNonInitialTransition EOF
             {
              before(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1336,21 +1413,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNonInitialTransition"
-    // InternalFSM.g:493:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ;
+    // InternalFSM.g:519:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ;
     public final void ruleNonInitialTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:497:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) )
-            // InternalFSM.g:498:1: ( ( rule__NonInitialTransition__Alternatives ) )
+            // InternalFSM.g:523:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) )
+            // InternalFSM.g:524:1: ( ( rule__NonInitialTransition__Alternatives ) )
             {
-            // InternalFSM.g:498:1: ( ( rule__NonInitialTransition__Alternatives ) )
-            // InternalFSM.g:499:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalFSM.g:524:1: ( ( rule__NonInitialTransition__Alternatives ) )
+            // InternalFSM.g:525:1: ( rule__NonInitialTransition__Alternatives )
             {
              before(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); 
-            // InternalFSM.g:500:1: ( rule__NonInitialTransition__Alternatives )
-            // InternalFSM.g:500:2: rule__NonInitialTransition__Alternatives
+            // InternalFSM.g:526:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalFSM.g:526:2: rule__NonInitialTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NonInitialTransition__Alternatives();
@@ -1383,11 +1460,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalFSM.g:512:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ;
+    // InternalFSM.g:538:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ;
     public final void entryRuleTransitionChainStartTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:513:1: ( ruleTransitionChainStartTransition EOF )
-            // InternalFSM.g:514:1: ruleTransitionChainStartTransition EOF
+            // InternalFSM.g:539:1: ( ruleTransitionChainStartTransition EOF )
+            // InternalFSM.g:540:1: ruleTransitionChainStartTransition EOF
             {
              before(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1413,21 +1490,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionChainStartTransition"
-    // InternalFSM.g:521:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ;
+    // InternalFSM.g:547:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ;
     public final void ruleTransitionChainStartTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:525:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) )
-            // InternalFSM.g:526:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
+            // InternalFSM.g:551:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) )
+            // InternalFSM.g:552:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
             {
-            // InternalFSM.g:526:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
-            // InternalFSM.g:527:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalFSM.g:552:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
+            // InternalFSM.g:553:1: ( rule__TransitionChainStartTransition__Alternatives )
             {
              before(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); 
-            // InternalFSM.g:528:1: ( rule__TransitionChainStartTransition__Alternatives )
-            // InternalFSM.g:528:2: rule__TransitionChainStartTransition__Alternatives
+            // InternalFSM.g:554:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalFSM.g:554:2: rule__TransitionChainStartTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionChainStartTransition__Alternatives();
@@ -1460,11 +1537,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalFSM.g:540:1: entryRuleInitialTransition : ruleInitialTransition EOF ;
+    // InternalFSM.g:566:1: entryRuleInitialTransition : ruleInitialTransition EOF ;
     public final void entryRuleInitialTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:541:1: ( ruleInitialTransition EOF )
-            // InternalFSM.g:542:1: ruleInitialTransition EOF
+            // InternalFSM.g:567:1: ( ruleInitialTransition EOF )
+            // InternalFSM.g:568:1: ruleInitialTransition EOF
             {
              before(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1490,21 +1567,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInitialTransition"
-    // InternalFSM.g:549:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ;
+    // InternalFSM.g:575:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ;
     public final void ruleInitialTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:553:2: ( ( ( rule__InitialTransition__Group__0 ) ) )
-            // InternalFSM.g:554:1: ( ( rule__InitialTransition__Group__0 ) )
+            // InternalFSM.g:579:2: ( ( ( rule__InitialTransition__Group__0 ) ) )
+            // InternalFSM.g:580:1: ( ( rule__InitialTransition__Group__0 ) )
             {
-            // InternalFSM.g:554:1: ( ( rule__InitialTransition__Group__0 ) )
-            // InternalFSM.g:555:1: ( rule__InitialTransition__Group__0 )
+            // InternalFSM.g:580:1: ( ( rule__InitialTransition__Group__0 ) )
+            // InternalFSM.g:581:1: ( rule__InitialTransition__Group__0 )
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup()); 
-            // InternalFSM.g:556:1: ( rule__InitialTransition__Group__0 )
-            // InternalFSM.g:556:2: rule__InitialTransition__Group__0
+            // InternalFSM.g:582:1: ( rule__InitialTransition__Group__0 )
+            // InternalFSM.g:582:2: rule__InitialTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__0();
@@ -1537,11 +1614,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalFSM.g:568:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ;
+    // InternalFSM.g:594:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ;
     public final void entryRuleContinuationTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:569:1: ( ruleContinuationTransition EOF )
-            // InternalFSM.g:570:1: ruleContinuationTransition EOF
+            // InternalFSM.g:595:1: ( ruleContinuationTransition EOF )
+            // InternalFSM.g:596:1: ruleContinuationTransition EOF
             {
              before(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1567,21 +1644,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleContinuationTransition"
-    // InternalFSM.g:577:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ;
+    // InternalFSM.g:603:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ;
     public final void ruleContinuationTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:581:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) )
-            // InternalFSM.g:582:1: ( ( rule__ContinuationTransition__Group__0 ) )
+            // InternalFSM.g:607:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) )
+            // InternalFSM.g:608:1: ( ( rule__ContinuationTransition__Group__0 ) )
             {
-            // InternalFSM.g:582:1: ( ( rule__ContinuationTransition__Group__0 ) )
-            // InternalFSM.g:583:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalFSM.g:608:1: ( ( rule__ContinuationTransition__Group__0 ) )
+            // InternalFSM.g:609:1: ( rule__ContinuationTransition__Group__0 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup()); 
-            // InternalFSM.g:584:1: ( rule__ContinuationTransition__Group__0 )
-            // InternalFSM.g:584:2: rule__ContinuationTransition__Group__0
+            // InternalFSM.g:610:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalFSM.g:610:2: rule__ContinuationTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__0();
@@ -1614,11 +1691,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalFSM.g:596:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ;
+    // InternalFSM.g:622:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ;
     public final void entryRuleTriggeredTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:597:1: ( ruleTriggeredTransition EOF )
-            // InternalFSM.g:598:1: ruleTriggeredTransition EOF
+            // InternalFSM.g:623:1: ( ruleTriggeredTransition EOF )
+            // InternalFSM.g:624:1: ruleTriggeredTransition EOF
             {
              before(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1644,21 +1721,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTriggeredTransition"
-    // InternalFSM.g:605:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ;
+    // InternalFSM.g:631:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ;
     public final void ruleTriggeredTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:609:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) )
-            // InternalFSM.g:610:1: ( ( rule__TriggeredTransition__Group__0 ) )
+            // InternalFSM.g:635:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) )
+            // InternalFSM.g:636:1: ( ( rule__TriggeredTransition__Group__0 ) )
             {
-            // InternalFSM.g:610:1: ( ( rule__TriggeredTransition__Group__0 ) )
-            // InternalFSM.g:611:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalFSM.g:636:1: ( ( rule__TriggeredTransition__Group__0 ) )
+            // InternalFSM.g:637:1: ( rule__TriggeredTransition__Group__0 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup()); 
-            // InternalFSM.g:612:1: ( rule__TriggeredTransition__Group__0 )
-            // InternalFSM.g:612:2: rule__TriggeredTransition__Group__0
+            // InternalFSM.g:638:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalFSM.g:638:2: rule__TriggeredTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__0();
@@ -1691,11 +1768,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalFSM.g:624:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ;
+    // InternalFSM.g:650:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ;
     public final void entryRuleGuardedTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:625:1: ( ruleGuardedTransition EOF )
-            // InternalFSM.g:626:1: ruleGuardedTransition EOF
+            // InternalFSM.g:651:1: ( ruleGuardedTransition EOF )
+            // InternalFSM.g:652:1: ruleGuardedTransition EOF
             {
              before(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1721,21 +1798,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuardedTransition"
-    // InternalFSM.g:633:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ;
+    // InternalFSM.g:659:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ;
     public final void ruleGuardedTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:637:2: ( ( ( rule__GuardedTransition__Group__0 ) ) )
-            // InternalFSM.g:638:1: ( ( rule__GuardedTransition__Group__0 ) )
+            // InternalFSM.g:663:2: ( ( ( rule__GuardedTransition__Group__0 ) ) )
+            // InternalFSM.g:664:1: ( ( rule__GuardedTransition__Group__0 ) )
             {
-            // InternalFSM.g:638:1: ( ( rule__GuardedTransition__Group__0 ) )
-            // InternalFSM.g:639:1: ( rule__GuardedTransition__Group__0 )
+            // InternalFSM.g:664:1: ( ( rule__GuardedTransition__Group__0 ) )
+            // InternalFSM.g:665:1: ( rule__GuardedTransition__Group__0 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getGroup()); 
-            // InternalFSM.g:640:1: ( rule__GuardedTransition__Group__0 )
-            // InternalFSM.g:640:2: rule__GuardedTransition__Group__0
+            // InternalFSM.g:666:1: ( rule__GuardedTransition__Group__0 )
+            // InternalFSM.g:666:2: rule__GuardedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__0();
@@ -1768,11 +1845,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalFSM.g:652:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ;
+    // InternalFSM.g:678:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ;
     public final void entryRuleCPBranchTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:653:1: ( ruleCPBranchTransition EOF )
-            // InternalFSM.g:654:1: ruleCPBranchTransition EOF
+            // InternalFSM.g:679:1: ( ruleCPBranchTransition EOF )
+            // InternalFSM.g:680:1: ruleCPBranchTransition EOF
             {
              before(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1798,21 +1875,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCPBranchTransition"
-    // InternalFSM.g:661:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ;
+    // InternalFSM.g:687:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ;
     public final void ruleCPBranchTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:665:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) )
-            // InternalFSM.g:666:1: ( ( rule__CPBranchTransition__Group__0 ) )
+            // InternalFSM.g:691:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) )
+            // InternalFSM.g:692:1: ( ( rule__CPBranchTransition__Group__0 ) )
             {
-            // InternalFSM.g:666:1: ( ( rule__CPBranchTransition__Group__0 ) )
-            // InternalFSM.g:667:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalFSM.g:692:1: ( ( rule__CPBranchTransition__Group__0 ) )
+            // InternalFSM.g:693:1: ( rule__CPBranchTransition__Group__0 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getGroup()); 
-            // InternalFSM.g:668:1: ( rule__CPBranchTransition__Group__0 )
-            // InternalFSM.g:668:2: rule__CPBranchTransition__Group__0
+            // InternalFSM.g:694:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalFSM.g:694:2: rule__CPBranchTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__0();
@@ -1845,11 +1922,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalFSM.g:680:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ;
+    // InternalFSM.g:706:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ;
     public final void entryRuleRefinedTransition() throws RecognitionException {
         try {
-            // InternalFSM.g:681:1: ( ruleRefinedTransition EOF )
-            // InternalFSM.g:682:1: ruleRefinedTransition EOF
+            // InternalFSM.g:707:1: ( ruleRefinedTransition EOF )
+            // InternalFSM.g:708:1: ruleRefinedTransition EOF
             {
              before(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -1875,21 +1952,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefinedTransition"
-    // InternalFSM.g:689:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ;
+    // InternalFSM.g:715:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ;
     public final void ruleRefinedTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:693:2: ( ( ( rule__RefinedTransition__Group__0 ) ) )
-            // InternalFSM.g:694:1: ( ( rule__RefinedTransition__Group__0 ) )
+            // InternalFSM.g:719:2: ( ( ( rule__RefinedTransition__Group__0 ) ) )
+            // InternalFSM.g:720:1: ( ( rule__RefinedTransition__Group__0 ) )
             {
-            // InternalFSM.g:694:1: ( ( rule__RefinedTransition__Group__0 ) )
-            // InternalFSM.g:695:1: ( rule__RefinedTransition__Group__0 )
+            // InternalFSM.g:720:1: ( ( rule__RefinedTransition__Group__0 ) )
+            // InternalFSM.g:721:1: ( rule__RefinedTransition__Group__0 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getGroup()); 
-            // InternalFSM.g:696:1: ( rule__RefinedTransition__Group__0 )
-            // InternalFSM.g:696:2: rule__RefinedTransition__Group__0
+            // InternalFSM.g:722:1: ( rule__RefinedTransition__Group__0 )
+            // InternalFSM.g:722:2: rule__RefinedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__0();
@@ -1922,11 +1999,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalFSM.g:708:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ;
+    // InternalFSM.g:734:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ;
     public final void entryRuleTransitionTerminal() throws RecognitionException {
         try {
-            // InternalFSM.g:709:1: ( ruleTransitionTerminal EOF )
-            // InternalFSM.g:710:1: ruleTransitionTerminal EOF
+            // InternalFSM.g:735:1: ( ruleTransitionTerminal EOF )
+            // InternalFSM.g:736:1: ruleTransitionTerminal EOF
             {
              before(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -1952,21 +2029,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionTerminal"
-    // InternalFSM.g:717:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ;
+    // InternalFSM.g:743:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ;
     public final void ruleTransitionTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:721:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) )
-            // InternalFSM.g:722:1: ( ( rule__TransitionTerminal__Alternatives ) )
+            // InternalFSM.g:747:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) )
+            // InternalFSM.g:748:1: ( ( rule__TransitionTerminal__Alternatives ) )
             {
-            // InternalFSM.g:722:1: ( ( rule__TransitionTerminal__Alternatives ) )
-            // InternalFSM.g:723:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalFSM.g:748:1: ( ( rule__TransitionTerminal__Alternatives ) )
+            // InternalFSM.g:749:1: ( rule__TransitionTerminal__Alternatives )
             {
              before(grammarAccess.getTransitionTerminalAccess().getAlternatives()); 
-            // InternalFSM.g:724:1: ( rule__TransitionTerminal__Alternatives )
-            // InternalFSM.g:724:2: rule__TransitionTerminal__Alternatives
+            // InternalFSM.g:750:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalFSM.g:750:2: rule__TransitionTerminal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionTerminal__Alternatives();
@@ -1999,11 +2076,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalFSM.g:736:1: entryRuleStateTerminal : ruleStateTerminal EOF ;
+    // InternalFSM.g:762:1: entryRuleStateTerminal : ruleStateTerminal EOF ;
     public final void entryRuleStateTerminal() throws RecognitionException {
         try {
-            // InternalFSM.g:737:1: ( ruleStateTerminal EOF )
-            // InternalFSM.g:738:1: ruleStateTerminal EOF
+            // InternalFSM.g:763:1: ( ruleStateTerminal EOF )
+            // InternalFSM.g:764:1: ruleStateTerminal EOF
             {
              before(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -2029,21 +2106,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalFSM.g:745:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ;
+    // InternalFSM.g:771:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ;
     public final void ruleStateTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:749:2: ( ( ( rule__StateTerminal__StateAssignment ) ) )
-            // InternalFSM.g:750:1: ( ( rule__StateTerminal__StateAssignment ) )
+            // InternalFSM.g:775:2: ( ( ( rule__StateTerminal__StateAssignment ) ) )
+            // InternalFSM.g:776:1: ( ( rule__StateTerminal__StateAssignment ) )
             {
-            // InternalFSM.g:750:1: ( ( rule__StateTerminal__StateAssignment ) )
-            // InternalFSM.g:751:1: ( rule__StateTerminal__StateAssignment )
+            // InternalFSM.g:776:1: ( ( rule__StateTerminal__StateAssignment ) )
+            // InternalFSM.g:777:1: ( rule__StateTerminal__StateAssignment )
             {
              before(grammarAccess.getStateTerminalAccess().getStateAssignment()); 
-            // InternalFSM.g:752:1: ( rule__StateTerminal__StateAssignment )
-            // InternalFSM.g:752:2: rule__StateTerminal__StateAssignment
+            // InternalFSM.g:778:1: ( rule__StateTerminal__StateAssignment )
+            // InternalFSM.g:778:2: rule__StateTerminal__StateAssignment
             {
             pushFollow(FOLLOW_2);
             rule__StateTerminal__StateAssignment();
@@ -2076,11 +2153,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalFSM.g:764:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ;
+    // InternalFSM.g:790:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ;
     public final void entryRuleTrPointTerminal() throws RecognitionException {
         try {
-            // InternalFSM.g:765:1: ( ruleTrPointTerminal EOF )
-            // InternalFSM.g:766:1: ruleTrPointTerminal EOF
+            // InternalFSM.g:791:1: ( ruleTrPointTerminal EOF )
+            // InternalFSM.g:792:1: ruleTrPointTerminal EOF
             {
              before(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -2106,21 +2183,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrPointTerminal"
-    // InternalFSM.g:773:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ;
+    // InternalFSM.g:799:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ;
     public final void ruleTrPointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:777:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) )
-            // InternalFSM.g:778:1: ( ( rule__TrPointTerminal__Group__0 ) )
+            // InternalFSM.g:803:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) )
+            // InternalFSM.g:804:1: ( ( rule__TrPointTerminal__Group__0 ) )
             {
-            // InternalFSM.g:778:1: ( ( rule__TrPointTerminal__Group__0 ) )
-            // InternalFSM.g:779:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalFSM.g:804:1: ( ( rule__TrPointTerminal__Group__0 ) )
+            // InternalFSM.g:805:1: ( rule__TrPointTerminal__Group__0 )
             {
              before(grammarAccess.getTrPointTerminalAccess().getGroup()); 
-            // InternalFSM.g:780:1: ( rule__TrPointTerminal__Group__0 )
-            // InternalFSM.g:780:2: rule__TrPointTerminal__Group__0
+            // InternalFSM.g:806:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalFSM.g:806:2: rule__TrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__0();
@@ -2153,11 +2230,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalFSM.g:792:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ;
+    // InternalFSM.g:818:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ;
     public final void entryRuleSubStateTrPointTerminal() throws RecognitionException {
         try {
-            // InternalFSM.g:793:1: ( ruleSubStateTrPointTerminal EOF )
-            // InternalFSM.g:794:1: ruleSubStateTrPointTerminal EOF
+            // InternalFSM.g:819:1: ( ruleSubStateTrPointTerminal EOF )
+            // InternalFSM.g:820:1: ruleSubStateTrPointTerminal EOF
             {
              before(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -2183,21 +2260,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubStateTrPointTerminal"
-    // InternalFSM.g:801:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ;
+    // InternalFSM.g:827:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ;
     public final void ruleSubStateTrPointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:805:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) )
-            // InternalFSM.g:806:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
+            // InternalFSM.g:831:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) )
+            // InternalFSM.g:832:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
             {
-            // InternalFSM.g:806:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
-            // InternalFSM.g:807:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalFSM.g:832:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
+            // InternalFSM.g:833:1: ( rule__SubStateTrPointTerminal__Group__0 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); 
-            // InternalFSM.g:808:1: ( rule__SubStateTrPointTerminal__Group__0 )
-            // InternalFSM.g:808:2: rule__SubStateTrPointTerminal__Group__0
+            // InternalFSM.g:834:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalFSM.g:834:2: rule__SubStateTrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__0();
@@ -2230,11 +2307,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalFSM.g:820:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ;
+    // InternalFSM.g:846:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ;
     public final void entryRuleChoicepointTerminal() throws RecognitionException {
         try {
-            // InternalFSM.g:821:1: ( ruleChoicepointTerminal EOF )
-            // InternalFSM.g:822:1: ruleChoicepointTerminal EOF
+            // InternalFSM.g:847:1: ( ruleChoicepointTerminal EOF )
+            // InternalFSM.g:848:1: ruleChoicepointTerminal EOF
             {
              before(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -2260,21 +2337,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleChoicepointTerminal"
-    // InternalFSM.g:829:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ;
+    // InternalFSM.g:855:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ;
     public final void ruleChoicepointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:833:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) )
-            // InternalFSM.g:834:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
+            // InternalFSM.g:859:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) )
+            // InternalFSM.g:860:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
             {
-            // InternalFSM.g:834:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
-            // InternalFSM.g:835:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalFSM.g:860:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
+            // InternalFSM.g:861:1: ( rule__ChoicepointTerminal__Group__0 )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getGroup()); 
-            // InternalFSM.g:836:1: ( rule__ChoicepointTerminal__Group__0 )
-            // InternalFSM.g:836:2: rule__ChoicepointTerminal__Group__0
+            // InternalFSM.g:862:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalFSM.g:862:2: rule__ChoicepointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__0();
@@ -2307,11 +2384,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalFSM.g:848:1: entryRuleTrigger : ruleTrigger EOF ;
+    // InternalFSM.g:874:1: entryRuleTrigger : ruleTrigger EOF ;
     public final void entryRuleTrigger() throws RecognitionException {
         try {
-            // InternalFSM.g:849:1: ( ruleTrigger EOF )
-            // InternalFSM.g:850:1: ruleTrigger EOF
+            // InternalFSM.g:875:1: ( ruleTrigger EOF )
+            // InternalFSM.g:876:1: ruleTrigger EOF
             {
              before(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -2337,21 +2414,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrigger"
-    // InternalFSM.g:857:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ;
+    // InternalFSM.g:883:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ;
     public final void ruleTrigger() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:861:2: ( ( ( rule__Trigger__Group__0 ) ) )
-            // InternalFSM.g:862:1: ( ( rule__Trigger__Group__0 ) )
+            // InternalFSM.g:887:2: ( ( ( rule__Trigger__Group__0 ) ) )
+            // InternalFSM.g:888:1: ( ( rule__Trigger__Group__0 ) )
             {
-            // InternalFSM.g:862:1: ( ( rule__Trigger__Group__0 ) )
-            // InternalFSM.g:863:1: ( rule__Trigger__Group__0 )
+            // InternalFSM.g:888:1: ( ( rule__Trigger__Group__0 ) )
+            // InternalFSM.g:889:1: ( rule__Trigger__Group__0 )
             {
              before(grammarAccess.getTriggerAccess().getGroup()); 
-            // InternalFSM.g:864:1: ( rule__Trigger__Group__0 )
-            // InternalFSM.g:864:2: rule__Trigger__Group__0
+            // InternalFSM.g:890:1: ( rule__Trigger__Group__0 )
+            // InternalFSM.g:890:2: rule__Trigger__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__0();
@@ -2384,11 +2461,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalFSM.g:876:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ;
+    // InternalFSM.g:902:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ;
     public final void entryRuleMessageFromIf() throws RecognitionException {
         try {
-            // InternalFSM.g:877:1: ( ruleMessageFromIf EOF )
-            // InternalFSM.g:878:1: ruleMessageFromIf EOF
+            // InternalFSM.g:903:1: ( ruleMessageFromIf EOF )
+            // InternalFSM.g:904:1: ruleMessageFromIf EOF
             {
              before(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -2414,21 +2491,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMessageFromIf"
-    // InternalFSM.g:885:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ;
+    // InternalFSM.g:911:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ;
     public final void ruleMessageFromIf() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:889:2: ( ( ( rule__MessageFromIf__Group__0 ) ) )
-            // InternalFSM.g:890:1: ( ( rule__MessageFromIf__Group__0 ) )
+            // InternalFSM.g:915:2: ( ( ( rule__MessageFromIf__Group__0 ) ) )
+            // InternalFSM.g:916:1: ( ( rule__MessageFromIf__Group__0 ) )
             {
-            // InternalFSM.g:890:1: ( ( rule__MessageFromIf__Group__0 ) )
-            // InternalFSM.g:891:1: ( rule__MessageFromIf__Group__0 )
+            // InternalFSM.g:916:1: ( ( rule__MessageFromIf__Group__0 ) )
+            // InternalFSM.g:917:1: ( rule__MessageFromIf__Group__0 )
             {
              before(grammarAccess.getMessageFromIfAccess().getGroup()); 
-            // InternalFSM.g:892:1: ( rule__MessageFromIf__Group__0 )
-            // InternalFSM.g:892:2: rule__MessageFromIf__Group__0
+            // InternalFSM.g:918:1: ( rule__MessageFromIf__Group__0 )
+            // InternalFSM.g:918:2: rule__MessageFromIf__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__0();
@@ -2461,11 +2538,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalFSM.g:906:1: entryRuleGuard : ruleGuard EOF ;
+    // InternalFSM.g:932:1: entryRuleGuard : ruleGuard EOF ;
     public final void entryRuleGuard() throws RecognitionException {
         try {
-            // InternalFSM.g:907:1: ( ruleGuard EOF )
-            // InternalFSM.g:908:1: ruleGuard EOF
+            // InternalFSM.g:933:1: ( ruleGuard EOF )
+            // InternalFSM.g:934:1: ruleGuard EOF
             {
              before(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -2491,21 +2568,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuard"
-    // InternalFSM.g:915:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ;
+    // InternalFSM.g:941:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ;
     public final void ruleGuard() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:919:2: ( ( ( rule__Guard__Group__0 ) ) )
-            // InternalFSM.g:920:1: ( ( rule__Guard__Group__0 ) )
+            // InternalFSM.g:945:2: ( ( ( rule__Guard__Group__0 ) ) )
+            // InternalFSM.g:946:1: ( ( rule__Guard__Group__0 ) )
             {
-            // InternalFSM.g:920:1: ( ( rule__Guard__Group__0 ) )
-            // InternalFSM.g:921:1: ( rule__Guard__Group__0 )
+            // InternalFSM.g:946:1: ( ( rule__Guard__Group__0 ) )
+            // InternalFSM.g:947:1: ( rule__Guard__Group__0 )
             {
              before(grammarAccess.getGuardAccess().getGroup()); 
-            // InternalFSM.g:922:1: ( rule__Guard__Group__0 )
-            // InternalFSM.g:922:2: rule__Guard__Group__0
+            // InternalFSM.g:948:1: ( rule__Guard__Group__0 )
+            // InternalFSM.g:948:2: rule__Guard__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__0();
@@ -2538,11 +2615,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalFSM.g:936:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ;
+    // InternalFSM.g:962:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ;
     public final void entryRuleSemanticsRule() throws RecognitionException {
         try {
-            // InternalFSM.g:937:1: ( ruleSemanticsRule EOF )
-            // InternalFSM.g:938:1: ruleSemanticsRule EOF
+            // InternalFSM.g:963:1: ( ruleSemanticsRule EOF )
+            // InternalFSM.g:964:1: ruleSemanticsRule EOF
             {
              before(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -2568,21 +2645,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSemanticsRule"
-    // InternalFSM.g:945:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ;
+    // InternalFSM.g:971:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ;
     public final void ruleSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:949:2: ( ( ( rule__SemanticsRule__Alternatives ) ) )
-            // InternalFSM.g:950:1: ( ( rule__SemanticsRule__Alternatives ) )
+            // InternalFSM.g:975:2: ( ( ( rule__SemanticsRule__Alternatives ) ) )
+            // InternalFSM.g:976:1: ( ( rule__SemanticsRule__Alternatives ) )
             {
-            // InternalFSM.g:950:1: ( ( rule__SemanticsRule__Alternatives ) )
-            // InternalFSM.g:951:1: ( rule__SemanticsRule__Alternatives )
+            // InternalFSM.g:976:1: ( ( rule__SemanticsRule__Alternatives ) )
+            // InternalFSM.g:977:1: ( rule__SemanticsRule__Alternatives )
             {
              before(grammarAccess.getSemanticsRuleAccess().getAlternatives()); 
-            // InternalFSM.g:952:1: ( rule__SemanticsRule__Alternatives )
-            // InternalFSM.g:952:2: rule__SemanticsRule__Alternatives
+            // InternalFSM.g:978:1: ( rule__SemanticsRule__Alternatives )
+            // InternalFSM.g:978:2: rule__SemanticsRule__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__SemanticsRule__Alternatives();
@@ -2615,11 +2692,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalFSM.g:964:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ;
+    // InternalFSM.g:990:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ;
     public final void entryRuleInSemanticsRule() throws RecognitionException {
         try {
-            // InternalFSM.g:965:1: ( ruleInSemanticsRule EOF )
-            // InternalFSM.g:966:1: ruleInSemanticsRule EOF
+            // InternalFSM.g:991:1: ( ruleInSemanticsRule EOF )
+            // InternalFSM.g:992:1: ruleInSemanticsRule EOF
             {
              before(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -2645,21 +2722,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInSemanticsRule"
-    // InternalFSM.g:973:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ;
+    // InternalFSM.g:999:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ;
     public final void ruleInSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:977:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) )
-            // InternalFSM.g:978:1: ( ( rule__InSemanticsRule__Group__0 ) )
+            // InternalFSM.g:1003:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) )
+            // InternalFSM.g:1004:1: ( ( rule__InSemanticsRule__Group__0 ) )
             {
-            // InternalFSM.g:978:1: ( ( rule__InSemanticsRule__Group__0 ) )
-            // InternalFSM.g:979:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalFSM.g:1004:1: ( ( rule__InSemanticsRule__Group__0 ) )
+            // InternalFSM.g:1005:1: ( rule__InSemanticsRule__Group__0 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup()); 
-            // InternalFSM.g:980:1: ( rule__InSemanticsRule__Group__0 )
-            // InternalFSM.g:980:2: rule__InSemanticsRule__Group__0
+            // InternalFSM.g:1006:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalFSM.g:1006:2: rule__InSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__0();
@@ -2692,11 +2769,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalFSM.g:992:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ;
+    // InternalFSM.g:1018:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ;
     public final void entryRuleOutSemanticsRule() throws RecognitionException {
         try {
-            // InternalFSM.g:993:1: ( ruleOutSemanticsRule EOF )
-            // InternalFSM.g:994:1: ruleOutSemanticsRule EOF
+            // InternalFSM.g:1019:1: ( ruleOutSemanticsRule EOF )
+            // InternalFSM.g:1020:1: ruleOutSemanticsRule EOF
             {
              before(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -2722,21 +2799,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleOutSemanticsRule"
-    // InternalFSM.g:1001:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ;
+    // InternalFSM.g:1027:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ;
     public final void ruleOutSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1005:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) )
-            // InternalFSM.g:1006:1: ( ( rule__OutSemanticsRule__Group__0 ) )
+            // InternalFSM.g:1031:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) )
+            // InternalFSM.g:1032:1: ( ( rule__OutSemanticsRule__Group__0 ) )
             {
-            // InternalFSM.g:1006:1: ( ( rule__OutSemanticsRule__Group__0 ) )
-            // InternalFSM.g:1007:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalFSM.g:1032:1: ( ( rule__OutSemanticsRule__Group__0 ) )
+            // InternalFSM.g:1033:1: ( rule__OutSemanticsRule__Group__0 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup()); 
-            // InternalFSM.g:1008:1: ( rule__OutSemanticsRule__Group__0 )
-            // InternalFSM.g:1008:2: rule__OutSemanticsRule__Group__0
+            // InternalFSM.g:1034:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalFSM.g:1034:2: rule__OutSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__0();
@@ -2769,11 +2846,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalFSM.g:1022:1: entryRuleKeyValue : ruleKeyValue EOF ;
+    // InternalFSM.g:1048:1: entryRuleKeyValue : ruleKeyValue EOF ;
     public final void entryRuleKeyValue() throws RecognitionException {
         try {
-            // InternalFSM.g:1023:1: ( ruleKeyValue EOF )
-            // InternalFSM.g:1024:1: ruleKeyValue EOF
+            // InternalFSM.g:1049:1: ( ruleKeyValue EOF )
+            // InternalFSM.g:1050:1: ruleKeyValue EOF
             {
              before(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -2799,21 +2876,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleKeyValue"
-    // InternalFSM.g:1031:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ;
+    // InternalFSM.g:1057:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ;
     public final void ruleKeyValue() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1035:2: ( ( ( rule__KeyValue__Group__0 ) ) )
-            // InternalFSM.g:1036:1: ( ( rule__KeyValue__Group__0 ) )
+            // InternalFSM.g:1061:2: ( ( ( rule__KeyValue__Group__0 ) ) )
+            // InternalFSM.g:1062:1: ( ( rule__KeyValue__Group__0 ) )
             {
-            // InternalFSM.g:1036:1: ( ( rule__KeyValue__Group__0 ) )
-            // InternalFSM.g:1037:1: ( rule__KeyValue__Group__0 )
+            // InternalFSM.g:1062:1: ( ( rule__KeyValue__Group__0 ) )
+            // InternalFSM.g:1063:1: ( rule__KeyValue__Group__0 )
             {
              before(grammarAccess.getKeyValueAccess().getGroup()); 
-            // InternalFSM.g:1038:1: ( rule__KeyValue__Group__0 )
-            // InternalFSM.g:1038:2: rule__KeyValue__Group__0
+            // InternalFSM.g:1064:1: ( rule__KeyValue__Group__0 )
+            // InternalFSM.g:1064:2: rule__KeyValue__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__0();
@@ -2846,11 +2923,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationTargetType"
-    // InternalFSM.g:1052:1: entryRuleAnnotationTargetType : ruleAnnotationTargetType EOF ;
+    // InternalFSM.g:1078:1: entryRuleAnnotationTargetType : ruleAnnotationTargetType EOF ;
     public final void entryRuleAnnotationTargetType() throws RecognitionException {
         try {
-            // InternalFSM.g:1053:1: ( ruleAnnotationTargetType EOF )
-            // InternalFSM.g:1054:1: ruleAnnotationTargetType EOF
+            // InternalFSM.g:1079:1: ( ruleAnnotationTargetType EOF )
+            // InternalFSM.g:1080:1: ruleAnnotationTargetType EOF
             {
              before(grammarAccess.getAnnotationTargetTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -2876,17 +2953,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationTargetType"
-    // InternalFSM.g:1061:1: ruleAnnotationTargetType : ( RULE_ID ) ;
+    // InternalFSM.g:1087:1: ruleAnnotationTargetType : ( RULE_ID ) ;
     public final void ruleAnnotationTargetType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1065:2: ( ( RULE_ID ) )
-            // InternalFSM.g:1066:1: ( RULE_ID )
+            // InternalFSM.g:1091:2: ( ( RULE_ID ) )
+            // InternalFSM.g:1092:1: ( RULE_ID )
             {
-            // InternalFSM.g:1066:1: ( RULE_ID )
-            // InternalFSM.g:1067:1: RULE_ID
+            // InternalFSM.g:1092:1: ( RULE_ID )
+            // InternalFSM.g:1093:1: RULE_ID
             {
              before(grammarAccess.getAnnotationTargetTypeAccess().getIDTerminalRuleCall()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -2913,11 +2990,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalFSM.g:1080:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ;
+    // InternalFSM.g:1106:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ;
     public final void entryRuleAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalFSM.g:1081:1: ( ruleAnnotationAttribute EOF )
-            // InternalFSM.g:1082:1: ruleAnnotationAttribute EOF
+            // InternalFSM.g:1107:1: ( ruleAnnotationAttribute EOF )
+            // InternalFSM.g:1108:1: ruleAnnotationAttribute EOF
             {
              before(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -2943,21 +3020,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationAttribute"
-    // InternalFSM.g:1089:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ;
+    // InternalFSM.g:1115:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ;
     public final void ruleAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1093:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) )
-            // InternalFSM.g:1094:1: ( ( rule__AnnotationAttribute__Alternatives ) )
+            // InternalFSM.g:1119:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) )
+            // InternalFSM.g:1120:1: ( ( rule__AnnotationAttribute__Alternatives ) )
             {
-            // InternalFSM.g:1094:1: ( ( rule__AnnotationAttribute__Alternatives ) )
-            // InternalFSM.g:1095:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalFSM.g:1120:1: ( ( rule__AnnotationAttribute__Alternatives ) )
+            // InternalFSM.g:1121:1: ( rule__AnnotationAttribute__Alternatives )
             {
              before(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); 
-            // InternalFSM.g:1096:1: ( rule__AnnotationAttribute__Alternatives )
-            // InternalFSM.g:1096:2: rule__AnnotationAttribute__Alternatives
+            // InternalFSM.g:1122:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalFSM.g:1122:2: rule__AnnotationAttribute__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationAttribute__Alternatives();
@@ -2990,11 +3067,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalFSM.g:1108:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ;
+    // InternalFSM.g:1134:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ;
     public final void entryRuleSimpleAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalFSM.g:1109:1: ( ruleSimpleAnnotationAttribute EOF )
-            // InternalFSM.g:1110:1: ruleSimpleAnnotationAttribute EOF
+            // InternalFSM.g:1135:1: ( ruleSimpleAnnotationAttribute EOF )
+            // InternalFSM.g:1136:1: ruleSimpleAnnotationAttribute EOF
             {
              before(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -3020,21 +3097,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSimpleAnnotationAttribute"
-    // InternalFSM.g:1117:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ;
+    // InternalFSM.g:1143:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ;
     public final void ruleSimpleAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1121:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) )
-            // InternalFSM.g:1122:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
+            // InternalFSM.g:1147:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) )
+            // InternalFSM.g:1148:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
             {
-            // InternalFSM.g:1122:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
-            // InternalFSM.g:1123:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalFSM.g:1148:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
+            // InternalFSM.g:1149:1: ( rule__SimpleAnnotationAttribute__Group__0 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); 
-            // InternalFSM.g:1124:1: ( rule__SimpleAnnotationAttribute__Group__0 )
-            // InternalFSM.g:1124:2: rule__SimpleAnnotationAttribute__Group__0
+            // InternalFSM.g:1150:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalFSM.g:1150:2: rule__SimpleAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__0();
@@ -3067,11 +3144,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalFSM.g:1136:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ;
+    // InternalFSM.g:1162:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ;
     public final void entryRuleEnumAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalFSM.g:1137:1: ( ruleEnumAnnotationAttribute EOF )
-            // InternalFSM.g:1138:1: ruleEnumAnnotationAttribute EOF
+            // InternalFSM.g:1163:1: ( ruleEnumAnnotationAttribute EOF )
+            // InternalFSM.g:1164:1: ruleEnumAnnotationAttribute EOF
             {
              before(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -3097,21 +3174,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEnumAnnotationAttribute"
-    // InternalFSM.g:1145:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ;
+    // InternalFSM.g:1171:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ;
     public final void ruleEnumAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1149:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) )
-            // InternalFSM.g:1150:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
+            // InternalFSM.g:1175:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) )
+            // InternalFSM.g:1176:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
             {
-            // InternalFSM.g:1150:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
-            // InternalFSM.g:1151:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalFSM.g:1176:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
+            // InternalFSM.g:1177:1: ( rule__EnumAnnotationAttribute__Group__0 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); 
-            // InternalFSM.g:1152:1: ( rule__EnumAnnotationAttribute__Group__0 )
-            // InternalFSM.g:1152:2: rule__EnumAnnotationAttribute__Group__0
+            // InternalFSM.g:1178:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalFSM.g:1178:2: rule__EnumAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__0();
@@ -3144,11 +3221,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalFSM.g:1166:1: entryRuleImportedFQN : ruleImportedFQN EOF ;
+    // InternalFSM.g:1192:1: entryRuleImportedFQN : ruleImportedFQN EOF ;
     public final void entryRuleImportedFQN() throws RecognitionException {
         try {
-            // InternalFSM.g:1167:1: ( ruleImportedFQN EOF )
-            // InternalFSM.g:1168:1: ruleImportedFQN EOF
+            // InternalFSM.g:1193:1: ( ruleImportedFQN EOF )
+            // InternalFSM.g:1194:1: ruleImportedFQN EOF
             {
              before(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -3174,21 +3251,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleImportedFQN"
-    // InternalFSM.g:1175:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ;
+    // InternalFSM.g:1201:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ;
     public final void ruleImportedFQN() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1179:2: ( ( ( rule__ImportedFQN__Group__0 ) ) )
-            // InternalFSM.g:1180:1: ( ( rule__ImportedFQN__Group__0 ) )
+            // InternalFSM.g:1205:2: ( ( ( rule__ImportedFQN__Group__0 ) ) )
+            // InternalFSM.g:1206:1: ( ( rule__ImportedFQN__Group__0 ) )
             {
-            // InternalFSM.g:1180:1: ( ( rule__ImportedFQN__Group__0 ) )
-            // InternalFSM.g:1181:1: ( rule__ImportedFQN__Group__0 )
+            // InternalFSM.g:1206:1: ( ( rule__ImportedFQN__Group__0 ) )
+            // InternalFSM.g:1207:1: ( rule__ImportedFQN__Group__0 )
             {
              before(grammarAccess.getImportedFQNAccess().getGroup()); 
-            // InternalFSM.g:1182:1: ( rule__ImportedFQN__Group__0 )
-            // InternalFSM.g:1182:2: rule__ImportedFQN__Group__0
+            // InternalFSM.g:1208:1: ( rule__ImportedFQN__Group__0 )
+            // InternalFSM.g:1208:2: rule__ImportedFQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__0();
@@ -3221,11 +3298,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalFSM.g:1194:1: entryRuleDocumentation : ruleDocumentation EOF ;
+    // InternalFSM.g:1220:1: entryRuleDocumentation : ruleDocumentation EOF ;
     public final void entryRuleDocumentation() throws RecognitionException {
         try {
-            // InternalFSM.g:1195:1: ( ruleDocumentation EOF )
-            // InternalFSM.g:1196:1: ruleDocumentation EOF
+            // InternalFSM.g:1221:1: ( ruleDocumentation EOF )
+            // InternalFSM.g:1222:1: ruleDocumentation EOF
             {
              before(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -3251,21 +3328,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDocumentation"
-    // InternalFSM.g:1203:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ;
+    // InternalFSM.g:1229:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ;
     public final void ruleDocumentation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1207:2: ( ( ( rule__Documentation__Group__0 ) ) )
-            // InternalFSM.g:1208:1: ( ( rule__Documentation__Group__0 ) )
+            // InternalFSM.g:1233:2: ( ( ( rule__Documentation__Group__0 ) ) )
+            // InternalFSM.g:1234:1: ( ( rule__Documentation__Group__0 ) )
             {
-            // InternalFSM.g:1208:1: ( ( rule__Documentation__Group__0 ) )
-            // InternalFSM.g:1209:1: ( rule__Documentation__Group__0 )
+            // InternalFSM.g:1234:1: ( ( rule__Documentation__Group__0 ) )
+            // InternalFSM.g:1235:1: ( rule__Documentation__Group__0 )
             {
              before(grammarAccess.getDocumentationAccess().getGroup()); 
-            // InternalFSM.g:1210:1: ( rule__Documentation__Group__0 )
-            // InternalFSM.g:1210:2: rule__Documentation__Group__0
+            // InternalFSM.g:1236:1: ( rule__Documentation__Group__0 )
+            // InternalFSM.g:1236:2: rule__Documentation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__0();
@@ -3298,11 +3375,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalFSM.g:1226:1: entryRuleLiteral : ruleLiteral EOF ;
+    // InternalFSM.g:1252:1: entryRuleLiteral : ruleLiteral EOF ;
     public final void entryRuleLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1227:1: ( ruleLiteral EOF )
-            // InternalFSM.g:1228:1: ruleLiteral EOF
+            // InternalFSM.g:1253:1: ( ruleLiteral EOF )
+            // InternalFSM.g:1254:1: ruleLiteral EOF
             {
              before(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3328,21 +3405,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteral"
-    // InternalFSM.g:1235:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
+    // InternalFSM.g:1261:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
     public final void ruleLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1239:2: ( ( ( rule__Literal__Alternatives ) ) )
-            // InternalFSM.g:1240:1: ( ( rule__Literal__Alternatives ) )
+            // InternalFSM.g:1265:2: ( ( ( rule__Literal__Alternatives ) ) )
+            // InternalFSM.g:1266:1: ( ( rule__Literal__Alternatives ) )
             {
-            // InternalFSM.g:1240:1: ( ( rule__Literal__Alternatives ) )
-            // InternalFSM.g:1241:1: ( rule__Literal__Alternatives )
+            // InternalFSM.g:1266:1: ( ( rule__Literal__Alternatives ) )
+            // InternalFSM.g:1267:1: ( rule__Literal__Alternatives )
             {
              before(grammarAccess.getLiteralAccess().getAlternatives()); 
-            // InternalFSM.g:1242:1: ( rule__Literal__Alternatives )
-            // InternalFSM.g:1242:2: rule__Literal__Alternatives
+            // InternalFSM.g:1268:1: ( rule__Literal__Alternatives )
+            // InternalFSM.g:1268:2: rule__Literal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Literal__Alternatives();
@@ -3375,11 +3452,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalFSM.g:1254:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ;
+    // InternalFSM.g:1280:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ;
     public final void entryRuleBooleanLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1255:1: ( ruleBooleanLiteral EOF )
-            // InternalFSM.g:1256:1: ruleBooleanLiteral EOF
+            // InternalFSM.g:1281:1: ( ruleBooleanLiteral EOF )
+            // InternalFSM.g:1282:1: ruleBooleanLiteral EOF
             {
              before(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3405,21 +3482,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleBooleanLiteral"
-    // InternalFSM.g:1263:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ;
+    // InternalFSM.g:1289:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ;
     public final void ruleBooleanLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1267:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) )
-            // InternalFSM.g:1268:1: ( ( rule__BooleanLiteral__Group__0 ) )
+            // InternalFSM.g:1293:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) )
+            // InternalFSM.g:1294:1: ( ( rule__BooleanLiteral__Group__0 ) )
             {
-            // InternalFSM.g:1268:1: ( ( rule__BooleanLiteral__Group__0 ) )
-            // InternalFSM.g:1269:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalFSM.g:1294:1: ( ( rule__BooleanLiteral__Group__0 ) )
+            // InternalFSM.g:1295:1: ( rule__BooleanLiteral__Group__0 )
             {
              before(grammarAccess.getBooleanLiteralAccess().getGroup()); 
-            // InternalFSM.g:1270:1: ( rule__BooleanLiteral__Group__0 )
-            // InternalFSM.g:1270:2: rule__BooleanLiteral__Group__0
+            // InternalFSM.g:1296:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalFSM.g:1296:2: rule__BooleanLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__0();
@@ -3452,11 +3529,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalFSM.g:1282:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
+    // InternalFSM.g:1308:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
     public final void entryRuleNumberLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1283:1: ( ruleNumberLiteral EOF )
-            // InternalFSM.g:1284:1: ruleNumberLiteral EOF
+            // InternalFSM.g:1309:1: ( ruleNumberLiteral EOF )
+            // InternalFSM.g:1310:1: ruleNumberLiteral EOF
             {
              before(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3482,21 +3559,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNumberLiteral"
-    // InternalFSM.g:1291:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ;
+    // InternalFSM.g:1317:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ;
     public final void ruleNumberLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1295:2: ( ( ( rule__NumberLiteral__Alternatives ) ) )
-            // InternalFSM.g:1296:1: ( ( rule__NumberLiteral__Alternatives ) )
+            // InternalFSM.g:1321:2: ( ( ( rule__NumberLiteral__Alternatives ) ) )
+            // InternalFSM.g:1322:1: ( ( rule__NumberLiteral__Alternatives ) )
             {
-            // InternalFSM.g:1296:1: ( ( rule__NumberLiteral__Alternatives ) )
-            // InternalFSM.g:1297:1: ( rule__NumberLiteral__Alternatives )
+            // InternalFSM.g:1322:1: ( ( rule__NumberLiteral__Alternatives ) )
+            // InternalFSM.g:1323:1: ( rule__NumberLiteral__Alternatives )
             {
              before(grammarAccess.getNumberLiteralAccess().getAlternatives()); 
-            // InternalFSM.g:1298:1: ( rule__NumberLiteral__Alternatives )
-            // InternalFSM.g:1298:2: rule__NumberLiteral__Alternatives
+            // InternalFSM.g:1324:1: ( rule__NumberLiteral__Alternatives )
+            // InternalFSM.g:1324:2: rule__NumberLiteral__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NumberLiteral__Alternatives();
@@ -3529,11 +3606,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalFSM.g:1310:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
+    // InternalFSM.g:1336:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
     public final void entryRuleRealLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1311:1: ( ruleRealLiteral EOF )
-            // InternalFSM.g:1312:1: ruleRealLiteral EOF
+            // InternalFSM.g:1337:1: ( ruleRealLiteral EOF )
+            // InternalFSM.g:1338:1: ruleRealLiteral EOF
             {
              before(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3559,21 +3636,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRealLiteral"
-    // InternalFSM.g:1319:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ;
+    // InternalFSM.g:1345:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ;
     public final void ruleRealLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1323:2: ( ( ( rule__RealLiteral__Group__0 ) ) )
-            // InternalFSM.g:1324:1: ( ( rule__RealLiteral__Group__0 ) )
+            // InternalFSM.g:1349:2: ( ( ( rule__RealLiteral__Group__0 ) ) )
+            // InternalFSM.g:1350:1: ( ( rule__RealLiteral__Group__0 ) )
             {
-            // InternalFSM.g:1324:1: ( ( rule__RealLiteral__Group__0 ) )
-            // InternalFSM.g:1325:1: ( rule__RealLiteral__Group__0 )
+            // InternalFSM.g:1350:1: ( ( rule__RealLiteral__Group__0 ) )
+            // InternalFSM.g:1351:1: ( rule__RealLiteral__Group__0 )
             {
              before(grammarAccess.getRealLiteralAccess().getGroup()); 
-            // InternalFSM.g:1326:1: ( rule__RealLiteral__Group__0 )
-            // InternalFSM.g:1326:2: rule__RealLiteral__Group__0
+            // InternalFSM.g:1352:1: ( rule__RealLiteral__Group__0 )
+            // InternalFSM.g:1352:2: rule__RealLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__0();
@@ -3606,11 +3683,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalFSM.g:1338:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
+    // InternalFSM.g:1364:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
     public final void entryRuleIntLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1339:1: ( ruleIntLiteral EOF )
-            // InternalFSM.g:1340:1: ruleIntLiteral EOF
+            // InternalFSM.g:1365:1: ( ruleIntLiteral EOF )
+            // InternalFSM.g:1366:1: ruleIntLiteral EOF
             {
              before(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3636,21 +3713,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleIntLiteral"
-    // InternalFSM.g:1347:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ;
+    // InternalFSM.g:1373:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ;
     public final void ruleIntLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1351:2: ( ( ( rule__IntLiteral__Group__0 ) ) )
-            // InternalFSM.g:1352:1: ( ( rule__IntLiteral__Group__0 ) )
+            // InternalFSM.g:1377:2: ( ( ( rule__IntLiteral__Group__0 ) ) )
+            // InternalFSM.g:1378:1: ( ( rule__IntLiteral__Group__0 ) )
             {
-            // InternalFSM.g:1352:1: ( ( rule__IntLiteral__Group__0 ) )
-            // InternalFSM.g:1353:1: ( rule__IntLiteral__Group__0 )
+            // InternalFSM.g:1378:1: ( ( rule__IntLiteral__Group__0 ) )
+            // InternalFSM.g:1379:1: ( rule__IntLiteral__Group__0 )
             {
              before(grammarAccess.getIntLiteralAccess().getGroup()); 
-            // InternalFSM.g:1354:1: ( rule__IntLiteral__Group__0 )
-            // InternalFSM.g:1354:2: rule__IntLiteral__Group__0
+            // InternalFSM.g:1380:1: ( rule__IntLiteral__Group__0 )
+            // InternalFSM.g:1380:2: rule__IntLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__0();
@@ -3683,11 +3760,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalFSM.g:1366:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
+    // InternalFSM.g:1392:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
     public final void entryRuleStringLiteral() throws RecognitionException {
         try {
-            // InternalFSM.g:1367:1: ( ruleStringLiteral EOF )
-            // InternalFSM.g:1368:1: ruleStringLiteral EOF
+            // InternalFSM.g:1393:1: ( ruleStringLiteral EOF )
+            // InternalFSM.g:1394:1: ruleStringLiteral EOF
             {
              before(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -3713,21 +3790,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStringLiteral"
-    // InternalFSM.g:1375:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
+    // InternalFSM.g:1401:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
     public final void ruleStringLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1379:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
-            // InternalFSM.g:1380:1: ( ( rule__StringLiteral__Group__0 ) )
+            // InternalFSM.g:1405:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
+            // InternalFSM.g:1406:1: ( ( rule__StringLiteral__Group__0 ) )
             {
-            // InternalFSM.g:1380:1: ( ( rule__StringLiteral__Group__0 ) )
-            // InternalFSM.g:1381:1: ( rule__StringLiteral__Group__0 )
+            // InternalFSM.g:1406:1: ( ( rule__StringLiteral__Group__0 ) )
+            // InternalFSM.g:1407:1: ( rule__StringLiteral__Group__0 )
             {
              before(grammarAccess.getStringLiteralAccess().getGroup()); 
-            // InternalFSM.g:1382:1: ( rule__StringLiteral__Group__0 )
-            // InternalFSM.g:1382:2: rule__StringLiteral__Group__0
+            // InternalFSM.g:1408:1: ( rule__StringLiteral__Group__0 )
+            // InternalFSM.g:1408:2: rule__StringLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__0();
@@ -3760,11 +3837,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalFSM.g:1394:1: entryRuleInteger : ruleInteger EOF ;
+    // InternalFSM.g:1420:1: entryRuleInteger : ruleInteger EOF ;
     public final void entryRuleInteger() throws RecognitionException {
         try {
-            // InternalFSM.g:1395:1: ( ruleInteger EOF )
-            // InternalFSM.g:1396:1: ruleInteger EOF
+            // InternalFSM.g:1421:1: ( ruleInteger EOF )
+            // InternalFSM.g:1422:1: ruleInteger EOF
             {
              before(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -3790,21 +3867,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInteger"
-    // InternalFSM.g:1403:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ;
+    // InternalFSM.g:1429:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ;
     public final void ruleInteger() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1407:2: ( ( ( rule__Integer__Alternatives ) ) )
-            // InternalFSM.g:1408:1: ( ( rule__Integer__Alternatives ) )
+            // InternalFSM.g:1433:2: ( ( ( rule__Integer__Alternatives ) ) )
+            // InternalFSM.g:1434:1: ( ( rule__Integer__Alternatives ) )
             {
-            // InternalFSM.g:1408:1: ( ( rule__Integer__Alternatives ) )
-            // InternalFSM.g:1409:1: ( rule__Integer__Alternatives )
+            // InternalFSM.g:1434:1: ( ( rule__Integer__Alternatives ) )
+            // InternalFSM.g:1435:1: ( rule__Integer__Alternatives )
             {
              before(grammarAccess.getIntegerAccess().getAlternatives()); 
-            // InternalFSM.g:1410:1: ( rule__Integer__Alternatives )
-            // InternalFSM.g:1410:2: rule__Integer__Alternatives
+            // InternalFSM.g:1436:1: ( rule__Integer__Alternatives )
+            // InternalFSM.g:1436:2: rule__Integer__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Alternatives();
@@ -3837,11 +3914,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalFSM.g:1422:1: entryRuleReal : ruleReal EOF ;
+    // InternalFSM.g:1448:1: entryRuleReal : ruleReal EOF ;
     public final void entryRuleReal() throws RecognitionException {
         try {
-            // InternalFSM.g:1423:1: ( ruleReal EOF )
-            // InternalFSM.g:1424:1: ruleReal EOF
+            // InternalFSM.g:1449:1: ( ruleReal EOF )
+            // InternalFSM.g:1450:1: ruleReal EOF
             {
              before(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -3867,21 +3944,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleReal"
-    // InternalFSM.g:1431:1: ruleReal : ( ( rule__Real__Alternatives ) ) ;
+    // InternalFSM.g:1457:1: ruleReal : ( ( rule__Real__Alternatives ) ) ;
     public final void ruleReal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1435:2: ( ( ( rule__Real__Alternatives ) ) )
-            // InternalFSM.g:1436:1: ( ( rule__Real__Alternatives ) )
+            // InternalFSM.g:1461:2: ( ( ( rule__Real__Alternatives ) ) )
+            // InternalFSM.g:1462:1: ( ( rule__Real__Alternatives ) )
             {
-            // InternalFSM.g:1436:1: ( ( rule__Real__Alternatives ) )
-            // InternalFSM.g:1437:1: ( rule__Real__Alternatives )
+            // InternalFSM.g:1462:1: ( ( rule__Real__Alternatives ) )
+            // InternalFSM.g:1463:1: ( rule__Real__Alternatives )
             {
              before(grammarAccess.getRealAccess().getAlternatives()); 
-            // InternalFSM.g:1438:1: ( rule__Real__Alternatives )
-            // InternalFSM.g:1438:2: rule__Real__Alternatives
+            // InternalFSM.g:1464:1: ( rule__Real__Alternatives )
+            // InternalFSM.g:1464:2: rule__Real__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Real__Alternatives();
@@ -3914,14 +3991,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalFSM.g:1450:1: entryRuleDecimal : ruleDecimal EOF ;
+    // InternalFSM.g:1476:1: entryRuleDecimal : ruleDecimal EOF ;
     public final void entryRuleDecimal() throws RecognitionException {
 
         	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
 
         try {
-            // InternalFSM.g:1454:1: ( ruleDecimal EOF )
-            // InternalFSM.g:1455:1: ruleDecimal EOF
+            // InternalFSM.g:1480:1: ( ruleDecimal EOF )
+            // InternalFSM.g:1481:1: ruleDecimal EOF
             {
              before(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -3950,22 +4027,22 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimal"
-    // InternalFSM.g:1465:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ;
+    // InternalFSM.g:1491:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ;
     public final void ruleDecimal() throws RecognitionException {
 
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1470:2: ( ( ( rule__Decimal__Group__0 ) ) )
-            // InternalFSM.g:1471:1: ( ( rule__Decimal__Group__0 ) )
+            // InternalFSM.g:1496:2: ( ( ( rule__Decimal__Group__0 ) ) )
+            // InternalFSM.g:1497:1: ( ( rule__Decimal__Group__0 ) )
             {
-            // InternalFSM.g:1471:1: ( ( rule__Decimal__Group__0 ) )
-            // InternalFSM.g:1472:1: ( rule__Decimal__Group__0 )
+            // InternalFSM.g:1497:1: ( ( rule__Decimal__Group__0 ) )
+            // InternalFSM.g:1498:1: ( rule__Decimal__Group__0 )
             {
              before(grammarAccess.getDecimalAccess().getGroup()); 
-            // InternalFSM.g:1473:1: ( rule__Decimal__Group__0 )
-            // InternalFSM.g:1473:2: rule__Decimal__Group__0
+            // InternalFSM.g:1499:1: ( rule__Decimal__Group__0 )
+            // InternalFSM.g:1499:2: rule__Decimal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__0();
@@ -3999,14 +4076,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalFSM.g:1486:1: entryRuleDecimalExp : ruleDecimalExp EOF ;
+    // InternalFSM.g:1512:1: entryRuleDecimalExp : ruleDecimalExp EOF ;
     public final void entryRuleDecimalExp() throws RecognitionException {
 
         	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
 
         try {
-            // InternalFSM.g:1490:1: ( ruleDecimalExp EOF )
-            // InternalFSM.g:1491:1: ruleDecimalExp EOF
+            // InternalFSM.g:1516:1: ( ruleDecimalExp EOF )
+            // InternalFSM.g:1517:1: ruleDecimalExp EOF
             {
              before(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -4035,22 +4112,22 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimalExp"
-    // InternalFSM.g:1501:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ;
+    // InternalFSM.g:1527:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ;
     public final void ruleDecimalExp() throws RecognitionException {
 
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1506:2: ( ( ( rule__DecimalExp__Group__0 ) ) )
-            // InternalFSM.g:1507:1: ( ( rule__DecimalExp__Group__0 ) )
+            // InternalFSM.g:1532:2: ( ( ( rule__DecimalExp__Group__0 ) ) )
+            // InternalFSM.g:1533:1: ( ( rule__DecimalExp__Group__0 ) )
             {
-            // InternalFSM.g:1507:1: ( ( rule__DecimalExp__Group__0 ) )
-            // InternalFSM.g:1508:1: ( rule__DecimalExp__Group__0 )
+            // InternalFSM.g:1533:1: ( ( rule__DecimalExp__Group__0 ) )
+            // InternalFSM.g:1534:1: ( rule__DecimalExp__Group__0 )
             {
              before(grammarAccess.getDecimalExpAccess().getGroup()); 
-            // InternalFSM.g:1509:1: ( rule__DecimalExp__Group__0 )
-            // InternalFSM.g:1509:2: rule__DecimalExp__Group__0
+            // InternalFSM.g:1535:1: ( rule__DecimalExp__Group__0 )
+            // InternalFSM.g:1535:2: rule__DecimalExp__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__0();
@@ -4084,11 +4161,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalFSM.g:1522:1: entryRuleFQN : ruleFQN EOF ;
+    // InternalFSM.g:1548:1: entryRuleFQN : ruleFQN EOF ;
     public final void entryRuleFQN() throws RecognitionException {
         try {
-            // InternalFSM.g:1523:1: ( ruleFQN EOF )
-            // InternalFSM.g:1524:1: ruleFQN EOF
+            // InternalFSM.g:1549:1: ( ruleFQN EOF )
+            // InternalFSM.g:1550:1: ruleFQN EOF
             {
              before(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -4114,21 +4191,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleFQN"
-    // InternalFSM.g:1531:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ;
+    // InternalFSM.g:1557:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ;
     public final void ruleFQN() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1535:2: ( ( ( rule__FQN__Group__0 ) ) )
-            // InternalFSM.g:1536:1: ( ( rule__FQN__Group__0 ) )
+            // InternalFSM.g:1561:2: ( ( ( rule__FQN__Group__0 ) ) )
+            // InternalFSM.g:1562:1: ( ( rule__FQN__Group__0 ) )
             {
-            // InternalFSM.g:1536:1: ( ( rule__FQN__Group__0 ) )
-            // InternalFSM.g:1537:1: ( rule__FQN__Group__0 )
+            // InternalFSM.g:1562:1: ( ( rule__FQN__Group__0 ) )
+            // InternalFSM.g:1563:1: ( rule__FQN__Group__0 )
             {
              before(grammarAccess.getFQNAccess().getGroup()); 
-            // InternalFSM.g:1538:1: ( rule__FQN__Group__0 )
-            // InternalFSM.g:1538:2: rule__FQN__Group__0
+            // InternalFSM.g:1564:1: ( rule__FQN__Group__0 )
+            // InternalFSM.g:1564:2: rule__FQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__0();
@@ -4161,21 +4238,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleComponentCommunicationType"
-    // InternalFSM.g:1551:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ;
+    // InternalFSM.g:1577:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ;
     public final void ruleComponentCommunicationType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1555:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) )
-            // InternalFSM.g:1556:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
+            // InternalFSM.g:1581:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) )
+            // InternalFSM.g:1582:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
             {
-            // InternalFSM.g:1556:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
-            // InternalFSM.g:1557:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalFSM.g:1582:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
+            // InternalFSM.g:1583:1: ( rule__ComponentCommunicationType__Alternatives )
             {
              before(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); 
-            // InternalFSM.g:1558:1: ( rule__ComponentCommunicationType__Alternatives )
-            // InternalFSM.g:1558:2: rule__ComponentCommunicationType__Alternatives
+            // InternalFSM.g:1584:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalFSM.g:1584:2: rule__ComponentCommunicationType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ComponentCommunicationType__Alternatives();
@@ -4208,21 +4285,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteralType"
-    // InternalFSM.g:1570:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ;
+    // InternalFSM.g:1596:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ;
     public final void ruleLiteralType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1574:1: ( ( ( rule__LiteralType__Alternatives ) ) )
-            // InternalFSM.g:1575:1: ( ( rule__LiteralType__Alternatives ) )
+            // InternalFSM.g:1600:1: ( ( ( rule__LiteralType__Alternatives ) ) )
+            // InternalFSM.g:1601:1: ( ( rule__LiteralType__Alternatives ) )
             {
-            // InternalFSM.g:1575:1: ( ( rule__LiteralType__Alternatives ) )
-            // InternalFSM.g:1576:1: ( rule__LiteralType__Alternatives )
+            // InternalFSM.g:1601:1: ( ( rule__LiteralType__Alternatives ) )
+            // InternalFSM.g:1602:1: ( rule__LiteralType__Alternatives )
             {
              before(grammarAccess.getLiteralTypeAccess().getAlternatives()); 
-            // InternalFSM.g:1577:1: ( rule__LiteralType__Alternatives )
-            // InternalFSM.g:1577:2: rule__LiteralType__Alternatives
+            // InternalFSM.g:1603:1: ( rule__LiteralType__Alternatives )
+            // InternalFSM.g:1603:2: rule__LiteralType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__LiteralType__Alternatives();
@@ -4255,13 +4332,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraphNode__Alternatives"
-    // InternalFSM.g:1588:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) );
+    // InternalFSM.g:1614:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) );
     public final void rule__StateGraphNode__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1592:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) )
+            // InternalFSM.g:1618:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) )
             int alt2=3;
             switch ( input.LA(1) ) {
             case 32:
@@ -4292,10 +4369,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             switch (alt2) {
                 case 1 :
-                    // InternalFSM.g:1593:1: ( ruleState )
+                    // InternalFSM.g:1619:1: ( ruleState )
                     {
-                    // InternalFSM.g:1593:1: ( ruleState )
-                    // InternalFSM.g:1594:1: ruleState
+                    // InternalFSM.g:1619:1: ( ruleState )
+                    // InternalFSM.g:1620:1: ruleState
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -4311,10 +4388,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1599:6: ( ruleChoicePoint )
+                    // InternalFSM.g:1625:6: ( ruleChoicePoint )
                     {
-                    // InternalFSM.g:1599:6: ( ruleChoicePoint )
-                    // InternalFSM.g:1600:1: ruleChoicePoint
+                    // InternalFSM.g:1625:6: ( ruleChoicePoint )
+                    // InternalFSM.g:1626:1: ruleChoicePoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -4330,10 +4407,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1605:6: ( ruleTrPoint )
+                    // InternalFSM.g:1631:6: ( ruleTrPoint )
                     {
-                    // InternalFSM.g:1605:6: ( ruleTrPoint )
-                    // InternalFSM.g:1606:1: ruleTrPoint
+                    // InternalFSM.g:1631:6: ( ruleTrPoint )
+                    // InternalFSM.g:1632:1: ruleTrPoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -4366,13 +4443,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Alternatives_2"
-    // InternalFSM.g:1617:1: rule__StateGraph__Alternatives_2 : ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) );
+    // InternalFSM.g:1643:1: rule__StateGraph__Alternatives_2 : ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) );
     public final void rule__StateGraph__Alternatives_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1621:1: ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) )
+            // InternalFSM.g:1647:1: ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) )
             int alt3=5;
             switch ( input.LA(1) ) {
             case 32:
@@ -4413,14 +4490,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             switch (alt3) {
                 case 1 :
-                    // InternalFSM.g:1622:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalFSM.g:1648:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
                     {
-                    // InternalFSM.g:1622:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
-                    // InternalFSM.g:1623:1: ( rule__StateGraph__StatesAssignment_2_0 )
+                    // InternalFSM.g:1648:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalFSM.g:1649:1: ( rule__StateGraph__StatesAssignment_2_0 )
                     {
                      before(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); 
-                    // InternalFSM.g:1624:1: ( rule__StateGraph__StatesAssignment_2_0 )
-                    // InternalFSM.g:1624:2: rule__StateGraph__StatesAssignment_2_0
+                    // InternalFSM.g:1650:1: ( rule__StateGraph__StatesAssignment_2_0 )
+                    // InternalFSM.g:1650:2: rule__StateGraph__StatesAssignment_2_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__StatesAssignment_2_0();
@@ -4438,14 +4515,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1628:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalFSM.g:1654:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
                     {
-                    // InternalFSM.g:1628:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
-                    // InternalFSM.g:1629:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
+                    // InternalFSM.g:1654:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalFSM.g:1655:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
                     {
                      before(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); 
-                    // InternalFSM.g:1630:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
-                    // InternalFSM.g:1630:2: rule__StateGraph__TrPointsAssignment_2_1
+                    // InternalFSM.g:1656:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
+                    // InternalFSM.g:1656:2: rule__StateGraph__TrPointsAssignment_2_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TrPointsAssignment_2_1();
@@ -4463,14 +4540,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1634:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalFSM.g:1660:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
                     {
-                    // InternalFSM.g:1634:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
-                    // InternalFSM.g:1635:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
+                    // InternalFSM.g:1660:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalFSM.g:1661:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
                     {
                      before(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); 
-                    // InternalFSM.g:1636:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
-                    // InternalFSM.g:1636:2: rule__StateGraph__ChPointsAssignment_2_2
+                    // InternalFSM.g:1662:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
+                    // InternalFSM.g:1662:2: rule__StateGraph__ChPointsAssignment_2_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__ChPointsAssignment_2_2();
@@ -4488,14 +4565,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:1640:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalFSM.g:1666:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
                     {
-                    // InternalFSM.g:1640:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
-                    // InternalFSM.g:1641:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
+                    // InternalFSM.g:1666:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalFSM.g:1667:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
                     {
                      before(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); 
-                    // InternalFSM.g:1642:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
-                    // InternalFSM.g:1642:2: rule__StateGraph__TransitionsAssignment_2_3
+                    // InternalFSM.g:1668:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
+                    // InternalFSM.g:1668:2: rule__StateGraph__TransitionsAssignment_2_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TransitionsAssignment_2_3();
@@ -4513,14 +4590,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalFSM.g:1646:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalFSM.g:1672:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
                     {
-                    // InternalFSM.g:1646:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
-                    // InternalFSM.g:1647:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
+                    // InternalFSM.g:1672:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalFSM.g:1673:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
                     {
                      before(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); 
-                    // InternalFSM.g:1648:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
-                    // InternalFSM.g:1648:2: rule__StateGraph__RefinedTransitionsAssignment_2_4
+                    // InternalFSM.g:1674:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
+                    // InternalFSM.g:1674:2: rule__StateGraph__RefinedTransitionsAssignment_2_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__RefinedTransitionsAssignment_2_4();
@@ -4555,13 +4632,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Alternatives_3"
-    // InternalFSM.g:1657:1: rule__StateMachine__Alternatives_3 : ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) );
+    // InternalFSM.g:1683:1: rule__StateMachine__Alternatives_3 : ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) );
     public final void rule__StateMachine__Alternatives_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1661:1: ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) )
+            // InternalFSM.g:1687:1: ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) )
             int alt4=5;
             switch ( input.LA(1) ) {
             case 32:
@@ -4602,14 +4679,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             switch (alt4) {
                 case 1 :
-                    // InternalFSM.g:1662:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalFSM.g:1688:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
                     {
-                    // InternalFSM.g:1662:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
-                    // InternalFSM.g:1663:1: ( rule__StateMachine__StatesAssignment_3_0 )
+                    // InternalFSM.g:1688:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalFSM.g:1689:1: ( rule__StateMachine__StatesAssignment_3_0 )
                     {
                      before(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); 
-                    // InternalFSM.g:1664:1: ( rule__StateMachine__StatesAssignment_3_0 )
-                    // InternalFSM.g:1664:2: rule__StateMachine__StatesAssignment_3_0
+                    // InternalFSM.g:1690:1: ( rule__StateMachine__StatesAssignment_3_0 )
+                    // InternalFSM.g:1690:2: rule__StateMachine__StatesAssignment_3_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__StatesAssignment_3_0();
@@ -4627,14 +4704,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1668:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalFSM.g:1694:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
                     {
-                    // InternalFSM.g:1668:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
-                    // InternalFSM.g:1669:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
+                    // InternalFSM.g:1694:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalFSM.g:1695:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
                     {
                      before(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); 
-                    // InternalFSM.g:1670:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
-                    // InternalFSM.g:1670:2: rule__StateMachine__TrPointsAssignment_3_1
+                    // InternalFSM.g:1696:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
+                    // InternalFSM.g:1696:2: rule__StateMachine__TrPointsAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TrPointsAssignment_3_1();
@@ -4652,14 +4729,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1674:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalFSM.g:1700:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
                     {
-                    // InternalFSM.g:1674:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
-                    // InternalFSM.g:1675:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
+                    // InternalFSM.g:1700:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalFSM.g:1701:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
                     {
                      before(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); 
-                    // InternalFSM.g:1676:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
-                    // InternalFSM.g:1676:2: rule__StateMachine__ChPointsAssignment_3_2
+                    // InternalFSM.g:1702:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
+                    // InternalFSM.g:1702:2: rule__StateMachine__ChPointsAssignment_3_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__ChPointsAssignment_3_2();
@@ -4677,14 +4754,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:1680:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalFSM.g:1706:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
                     {
-                    // InternalFSM.g:1680:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
-                    // InternalFSM.g:1681:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
+                    // InternalFSM.g:1706:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalFSM.g:1707:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
                     {
                      before(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); 
-                    // InternalFSM.g:1682:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
-                    // InternalFSM.g:1682:2: rule__StateMachine__TransitionsAssignment_3_3
+                    // InternalFSM.g:1708:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
+                    // InternalFSM.g:1708:2: rule__StateMachine__TransitionsAssignment_3_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TransitionsAssignment_3_3();
@@ -4702,14 +4779,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalFSM.g:1686:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalFSM.g:1712:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
                     {
-                    // InternalFSM.g:1686:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
-                    // InternalFSM.g:1687:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
+                    // InternalFSM.g:1712:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalFSM.g:1713:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
                     {
                      before(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); 
-                    // InternalFSM.g:1688:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
-                    // InternalFSM.g:1688:2: rule__StateMachine__RefinedTransitionsAssignment_3_4
+                    // InternalFSM.g:1714:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
+                    // InternalFSM.g:1714:2: rule__StateMachine__RefinedTransitionsAssignment_3_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__RefinedTransitionsAssignment_3_4();
@@ -4744,13 +4821,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__State__Alternatives"
-    // InternalFSM.g:1697:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) );
+    // InternalFSM.g:1723:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) );
     public final void rule__State__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1701:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) )
+            // InternalFSM.g:1727:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) )
             int alt5=2;
             int LA5_0 = input.LA(1);
 
@@ -4768,10 +4845,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             }
             switch (alt5) {
                 case 1 :
-                    // InternalFSM.g:1702:1: ( ruleSimpleState )
+                    // InternalFSM.g:1728:1: ( ruleSimpleState )
                     {
-                    // InternalFSM.g:1702:1: ( ruleSimpleState )
-                    // InternalFSM.g:1703:1: ruleSimpleState
+                    // InternalFSM.g:1728:1: ( ruleSimpleState )
+                    // InternalFSM.g:1729:1: ruleSimpleState
                     {
                      before(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -4787,10 +4864,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1708:6: ( ruleRefinedState )
+                    // InternalFSM.g:1734:6: ( ruleRefinedState )
                     {
-                    // InternalFSM.g:1708:6: ( ruleRefinedState )
-                    // InternalFSM.g:1709:1: ruleRefinedState
+                    // InternalFSM.g:1734:6: ( ruleRefinedState )
+                    // InternalFSM.g:1735:1: ruleRefinedState
                     {
                      before(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -4823,13 +4900,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Alternatives"
-    // InternalFSM.g:1719:1: rule__DetailCode__Alternatives : ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) );
+    // InternalFSM.g:1745:1: rule__DetailCode__Alternatives : ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) );
     public final void rule__DetailCode__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1723:1: ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) )
+            // InternalFSM.g:1749:1: ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) )
             int alt6=2;
             int LA6_0 = input.LA(1);
 
@@ -4847,14 +4924,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             }
             switch (alt6) {
                 case 1 :
-                    // InternalFSM.g:1724:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalFSM.g:1750:1: ( ( rule__DetailCode__Group_0__0 ) )
                     {
-                    // InternalFSM.g:1724:1: ( ( rule__DetailCode__Group_0__0 ) )
-                    // InternalFSM.g:1725:1: ( rule__DetailCode__Group_0__0 )
+                    // InternalFSM.g:1750:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalFSM.g:1751:1: ( rule__DetailCode__Group_0__0 )
                     {
                      before(grammarAccess.getDetailCodeAccess().getGroup_0()); 
-                    // InternalFSM.g:1726:1: ( rule__DetailCode__Group_0__0 )
-                    // InternalFSM.g:1726:2: rule__DetailCode__Group_0__0
+                    // InternalFSM.g:1752:1: ( rule__DetailCode__Group_0__0 )
+                    // InternalFSM.g:1752:2: rule__DetailCode__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_0__0();
@@ -4872,14 +4949,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1730:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalFSM.g:1756:6: ( ( rule__DetailCode__Group_1__0 ) )
                     {
-                    // InternalFSM.g:1730:6: ( ( rule__DetailCode__Group_1__0 ) )
-                    // InternalFSM.g:1731:1: ( rule__DetailCode__Group_1__0 )
+                    // InternalFSM.g:1756:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalFSM.g:1757:1: ( rule__DetailCode__Group_1__0 )
                     {
                      before(grammarAccess.getDetailCodeAccess().getGroup_1()); 
-                    // InternalFSM.g:1732:1: ( rule__DetailCode__Group_1__0 )
-                    // InternalFSM.g:1732:2: rule__DetailCode__Group_1__0
+                    // InternalFSM.g:1758:1: ( rule__DetailCode__Group_1__0 )
+                    // InternalFSM.g:1758:2: rule__DetailCode__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_1__0();
@@ -4914,13 +4991,13 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPoint__Alternatives"
-    // InternalFSM.g:1741:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) );
+    // InternalFSM.g:1767:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) );
     public final void rule__TrPoint__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1745:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) )
+            // InternalFSM.g:1771:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) )
             int alt7=3;
             switch ( input.LA(1) ) {
             case 38:
@@ -4948,10 +5025,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             switch (alt7) {
                 case 1 :
-                    // InternalFSM.g:1746:1: ( ruleTransitionPoint )
+                    // InternalFSM.g:1772:1: ( ruleTransitionPoint )
                     {
-                    // InternalFSM.g:1746:1: ( ruleTransitionPoint )
-                    // InternalFSM.g:1747:1: ruleTransitionPoint
+                    // InternalFSM.g:1772:1: ( ruleTransitionPoint )
+                    // InternalFSM.g:1773:1: ruleTransitionPoint
                     {
                      before(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -4967,10 +5044,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1752:6: ( ruleEntryPoint )
+                    // InternalFSM.g:1778:6: ( ruleEntryPoint )
                     {
-                    // InternalFSM.g:1752:6: ( ruleEntryPoint )
-                    // InternalFSM.g:1753:1: ruleEntryPoint
+                    // InternalFSM.g:1778:6: ( ruleEntryPoint )
+                    // InternalFSM.g:1779:1: ruleEntryPoint
                     {
                      before(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -4986,10 +5063,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1758:6: ( ruleExitPoint )
+                    // InternalFSM.g:1784:6: ( ruleExitPoint )
                     {
-                    // InternalFSM.g:1758:6: ( ruleExitPoint )
-                    // InternalFSM.g:1759:1: ruleExitPoint
+                    // InternalFSM.g:1784:6: ( ruleExitPoint )
+                    // InternalFSM.g:1785:1: ruleExitPoint
                     {
                      before(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -5021,81 +5098,160 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__TrPoint__Alternatives"
 
 
-    // $ANTLR start "rule__Transition__Alternatives"
-    // InternalFSM.g:1770:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) );
-    public final void rule__Transition__Alternatives() throws RecognitionException {
+    // $ANTLR start "rule__TransitionBase__Alternatives"
+    // InternalFSM.g:1795:1: rule__TransitionBase__Alternatives : ( ( ruleTransition ) | ( ruleRefinedTransition ) );
+    public final void rule__TransitionBase__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1774:1: ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) )
+            // InternalFSM.g:1799:1: ( ( ruleTransition ) | ( ruleRefinedTransition ) )
             int alt8=2;
             int LA8_0 = input.LA(1);
 
             if ( (LA8_0==42) ) {
-                int LA8_1 = input.LA(2);
+                alt8=1;
+            }
+            else if ( (LA8_0==51) ) {
+                alt8=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 8, 0, input);
+
+                throw nvae;
+            }
+            switch (alt8) {
+                case 1 :
+                    // InternalFSM.g:1800:1: ( ruleTransition )
+                    {
+                    // InternalFSM.g:1800:1: ( ruleTransition )
+                    // InternalFSM.g:1801:1: ruleTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+                    pushFollow(FOLLOW_2);
+                    ruleTransition();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalFSM.g:1806:6: ( ruleRefinedTransition )
+                    {
+                    // InternalFSM.g:1806:6: ( ruleRefinedTransition )
+                    // InternalFSM.g:1807:1: ruleRefinedTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+                    pushFollow(FOLLOW_2);
+                    ruleRefinedTransition();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
 
-                if ( (LA8_1==RULE_ID) ) {
-                    int LA8_2 = input.LA(3);
+                    }
 
-                    if ( (LA8_2==43) ) {
-                        int LA8_3 = input.LA(4);
 
-                        if ( (LA8_3==44) ) {
-                            alt8=1;
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransitionBase__Alternatives"
+
+
+    // $ANTLR start "rule__Transition__Alternatives"
+    // InternalFSM.g:1817:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) );
+    public final void rule__Transition__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalFSM.g:1821:1: ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) )
+            int alt9=2;
+            int LA9_0 = input.LA(1);
+
+            if ( (LA9_0==42) ) {
+                int LA9_1 = input.LA(2);
+
+                if ( (LA9_1==RULE_ID) ) {
+                    int LA9_2 = input.LA(3);
+
+                    if ( (LA9_2==43) ) {
+                        int LA9_3 = input.LA(4);
+
+                        if ( (LA9_3==RULE_ID||LA9_3==52||LA9_3==54) ) {
+                            alt9=2;
                         }
-                        else if ( (LA8_3==RULE_ID||LA8_3==52||LA8_3==54) ) {
-                            alt8=2;
+                        else if ( (LA9_3==44) ) {
+                            alt9=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 8, 3, input);
+                                new NoViableAltException("", 9, 3, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 8, 2, input);
+                            new NoViableAltException("", 9, 2, input);
 
                         throw nvae;
                     }
                 }
-                else if ( (LA8_1==43) ) {
-                    int LA8_3 = input.LA(3);
+                else if ( (LA9_1==43) ) {
+                    int LA9_3 = input.LA(3);
 
-                    if ( (LA8_3==44) ) {
-                        alt8=1;
+                    if ( (LA9_3==RULE_ID||LA9_3==52||LA9_3==54) ) {
+                        alt9=2;
                     }
-                    else if ( (LA8_3==RULE_ID||LA8_3==52||LA8_3==54) ) {
-                        alt8=2;
+                    else if ( (LA9_3==44) ) {
+                        alt9=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 8, 3, input);
+                            new NoViableAltException("", 9, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 8, 1, input);
+                        new NoViableAltException("", 9, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 8, 0, input);
+                    new NoViableAltException("", 9, 0, input);
 
                 throw nvae;
             }
-            switch (alt8) {
+            switch (alt9) {
                 case 1 :
-                    // InternalFSM.g:1775:1: ( ruleInitialTransition )
+                    // InternalFSM.g:1822:1: ( ruleInitialTransition )
                     {
-                    // InternalFSM.g:1775:1: ( ruleInitialTransition )
-                    // InternalFSM.g:1776:1: ruleInitialTransition
+                    // InternalFSM.g:1822:1: ( ruleInitialTransition )
+                    // InternalFSM.g:1823:1: ruleInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5111,10 +5267,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1781:6: ( ruleNonInitialTransition )
+                    // InternalFSM.g:1828:6: ( ruleNonInitialTransition )
                     {
-                    // InternalFSM.g:1781:6: ( ruleNonInitialTransition )
-                    // InternalFSM.g:1782:1: ruleNonInitialTransition
+                    // InternalFSM.g:1828:6: ( ruleNonInitialTransition )
+                    // InternalFSM.g:1829:1: ruleNonInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5147,21 +5303,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NonInitialTransition__Alternatives"
-    // InternalFSM.g:1792:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );
+    // InternalFSM.g:1839:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );
     public final void rule__NonInitialTransition__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1796:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) )
-            int alt9=3;
-            alt9 = dfa9.predict(input);
-            switch (alt9) {
+            // InternalFSM.g:1843:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) )
+            int alt10=3;
+            alt10 = dfa10.predict(input);
+            switch (alt10) {
                 case 1 :
-                    // InternalFSM.g:1797:1: ( ruleTransitionChainStartTransition )
+                    // InternalFSM.g:1844:1: ( ruleTransitionChainStartTransition )
                     {
-                    // InternalFSM.g:1797:1: ( ruleTransitionChainStartTransition )
-                    // InternalFSM.g:1798:1: ruleTransitionChainStartTransition
+                    // InternalFSM.g:1844:1: ( ruleTransitionChainStartTransition )
+                    // InternalFSM.g:1845:1: ruleTransitionChainStartTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5177,10 +5333,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1803:6: ( ruleContinuationTransition )
+                    // InternalFSM.g:1850:6: ( ruleContinuationTransition )
                     {
-                    // InternalFSM.g:1803:6: ( ruleContinuationTransition )
-                    // InternalFSM.g:1804:1: ruleContinuationTransition
+                    // InternalFSM.g:1850:6: ( ruleContinuationTransition )
+                    // InternalFSM.g:1851:1: ruleContinuationTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5196,10 +5352,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1809:6: ( ruleCPBranchTransition )
+                    // InternalFSM.g:1856:6: ( ruleCPBranchTransition )
                     {
-                    // InternalFSM.g:1809:6: ( ruleCPBranchTransition )
-                    // InternalFSM.g:1810:1: ruleCPBranchTransition
+                    // InternalFSM.g:1856:6: ( ruleCPBranchTransition )
+                    // InternalFSM.g:1857:1: ruleCPBranchTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -5232,21 +5388,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionChainStartTransition__Alternatives"
-    // InternalFSM.g:1820:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );
+    // InternalFSM.g:1867:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );
     public final void rule__TransitionChainStartTransition__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1824:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) )
-            int alt10=2;
-            alt10 = dfa10.predict(input);
-            switch (alt10) {
+            // InternalFSM.g:1871:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) )
+            int alt11=2;
+            alt11 = dfa11.predict(input);
+            switch (alt11) {
                 case 1 :
-                    // InternalFSM.g:1825:1: ( ruleTriggeredTransition )
+                    // InternalFSM.g:1872:1: ( ruleTriggeredTransition )
                     {
-                    // InternalFSM.g:1825:1: ( ruleTriggeredTransition )
-                    // InternalFSM.g:1826:1: ruleTriggeredTransition
+                    // InternalFSM.g:1872:1: ( ruleTriggeredTransition )
+                    // InternalFSM.g:1873:1: ruleTriggeredTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5262,10 +5418,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1831:6: ( ruleGuardedTransition )
+                    // InternalFSM.g:1878:6: ( ruleGuardedTransition )
                     {
-                    // InternalFSM.g:1831:6: ( ruleGuardedTransition )
-                    // InternalFSM.g:1832:1: ruleGuardedTransition
+                    // InternalFSM.g:1878:6: ( ruleGuardedTransition )
+                    // InternalFSM.g:1879:1: ruleGuardedTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5298,28 +5454,28 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionTerminal__Alternatives"
-    // InternalFSM.g:1842:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) );
+    // InternalFSM.g:1889:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) );
     public final void rule__TransitionTerminal__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1846:1: ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) )
-            int alt11=4;
+            // InternalFSM.g:1893:1: ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) )
+            int alt12=4;
             switch ( input.LA(1) ) {
             case RULE_ID:
                 {
-                int LA11_1 = input.LA(2);
+                int LA12_1 = input.LA(2);
 
-                if ( (LA11_1==EOF||(LA11_1>=29 && LA11_1<=30)||LA11_1==32||(LA11_1>=37 && LA11_1<=42)||LA11_1==45||LA11_1==51||LA11_1==66||LA11_1==70) ) {
-                    alt11=1;
+                if ( (LA12_1==EOF||(LA12_1>=29 && LA12_1<=30)||LA12_1==32||(LA12_1>=37 && LA12_1<=42)||LA12_1==45||LA12_1==51||LA12_1==66||LA12_1==70) ) {
+                    alt12=1;
                 }
-                else if ( (LA11_1==53) ) {
-                    alt11=3;
+                else if ( (LA12_1==53) ) {
+                    alt12=3;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 11, 1, input);
+                        new NoViableAltException("", 12, 1, input);
 
                     throw nvae;
                 }
@@ -5327,27 +5483,27 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case 52:
                 {
-                alt11=2;
+                alt12=2;
                 }
                 break;
             case 54:
                 {
-                alt11=4;
+                alt12=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 11, 0, input);
+                    new NoViableAltException("", 12, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt11) {
+            switch (alt12) {
                 case 1 :
-                    // InternalFSM.g:1847:1: ( ruleStateTerminal )
+                    // InternalFSM.g:1894:1: ( ruleStateTerminal )
                     {
-                    // InternalFSM.g:1847:1: ( ruleStateTerminal )
-                    // InternalFSM.g:1848:1: ruleStateTerminal
+                    // InternalFSM.g:1894:1: ( ruleStateTerminal )
+                    // InternalFSM.g:1895:1: ruleStateTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5363,10 +5519,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1853:6: ( ruleTrPointTerminal )
+                    // InternalFSM.g:1900:6: ( ruleTrPointTerminal )
                     {
-                    // InternalFSM.g:1853:6: ( ruleTrPointTerminal )
-                    // InternalFSM.g:1854:1: ruleTrPointTerminal
+                    // InternalFSM.g:1900:6: ( ruleTrPointTerminal )
+                    // InternalFSM.g:1901:1: ruleTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5382,10 +5538,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1859:6: ( ruleSubStateTrPointTerminal )
+                    // InternalFSM.g:1906:6: ( ruleSubStateTrPointTerminal )
                     {
-                    // InternalFSM.g:1859:6: ( ruleSubStateTrPointTerminal )
-                    // InternalFSM.g:1860:1: ruleSubStateTrPointTerminal
+                    // InternalFSM.g:1906:6: ( ruleSubStateTrPointTerminal )
+                    // InternalFSM.g:1907:1: ruleSubStateTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -5401,10 +5557,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:1865:6: ( ruleChoicepointTerminal )
+                    // InternalFSM.g:1912:6: ( ruleChoicepointTerminal )
                     {
-                    // InternalFSM.g:1865:6: ( ruleChoicepointTerminal )
-                    // InternalFSM.g:1866:1: ruleChoicepointTerminal
+                    // InternalFSM.g:1912:6: ( ruleChoicepointTerminal )
+                    // InternalFSM.g:1913:1: ruleChoicepointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
                     pushFollow(FOLLOW_2);
@@ -5437,34 +5593,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SemanticsRule__Alternatives"
-    // InternalFSM.g:1876:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) );
+    // InternalFSM.g:1923:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) );
     public final void rule__SemanticsRule__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1880:1: ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) )
-            int alt12=2;
-            int LA12_0 = input.LA(1);
+            // InternalFSM.g:1927:1: ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) )
+            int alt13=2;
+            int LA13_0 = input.LA(1);
 
-            if ( (LA12_0==58) ) {
-                alt12=1;
+            if ( (LA13_0==58) ) {
+                alt13=1;
             }
-            else if ( (LA12_0==62) ) {
-                alt12=2;
+            else if ( (LA13_0==62) ) {
+                alt13=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 12, 0, input);
+                    new NoViableAltException("", 13, 0, input);
 
                 throw nvae;
             }
-            switch (alt12) {
+            switch (alt13) {
                 case 1 :
-                    // InternalFSM.g:1881:1: ( ruleInSemanticsRule )
+                    // InternalFSM.g:1928:1: ( ruleInSemanticsRule )
                     {
-                    // InternalFSM.g:1881:1: ( ruleInSemanticsRule )
-                    // InternalFSM.g:1882:1: ruleInSemanticsRule
+                    // InternalFSM.g:1928:1: ( ruleInSemanticsRule )
+                    // InternalFSM.g:1929:1: ruleInSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5480,10 +5636,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1887:6: ( ruleOutSemanticsRule )
+                    // InternalFSM.g:1934:6: ( ruleOutSemanticsRule )
                     {
-                    // InternalFSM.g:1887:6: ( ruleOutSemanticsRule )
-                    // InternalFSM.g:1888:1: ruleOutSemanticsRule
+                    // InternalFSM.g:1934:6: ( ruleOutSemanticsRule )
+                    // InternalFSM.g:1935:1: ruleOutSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5516,38 +5672,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Alternatives_3_1"
-    // InternalFSM.g:1898:1: rule__InSemanticsRule__Alternatives_3_1 : ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) );
+    // InternalFSM.g:1945:1: rule__InSemanticsRule__Alternatives_3_1 : ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) );
     public final void rule__InSemanticsRule__Alternatives_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1902:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) )
-            int alt13=2;
-            int LA13_0 = input.LA(1);
+            // InternalFSM.g:1949:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) )
+            int alt14=2;
+            int LA14_0 = input.LA(1);
 
-            if ( (LA13_0==58||LA13_0==62) ) {
-                alt13=1;
+            if ( (LA14_0==58||LA14_0==62) ) {
+                alt14=1;
             }
-            else if ( (LA13_0==59) ) {
-                alt13=2;
+            else if ( (LA14_0==59) ) {
+                alt14=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 13, 0, input);
+                    new NoViableAltException("", 14, 0, input);
 
                 throw nvae;
             }
-            switch (alt13) {
+            switch (alt14) {
                 case 1 :
-                    // InternalFSM.g:1903:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalFSM.g:1950:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
                     {
-                    // InternalFSM.g:1903:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
-                    // InternalFSM.g:1904:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalFSM.g:1950:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalFSM.g:1951:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
                     {
                      before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); 
-                    // InternalFSM.g:1905:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
-                    // InternalFSM.g:1905:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0
+                    // InternalFSM.g:1952:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalFSM.g:1952:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -5565,14 +5721,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1909:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalFSM.g:1956:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
                     {
-                    // InternalFSM.g:1909:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
-                    // InternalFSM.g:1910:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
+                    // InternalFSM.g:1956:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalFSM.g:1957:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
                     {
                      before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); 
-                    // InternalFSM.g:1911:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
-                    // InternalFSM.g:1911:2: rule__InSemanticsRule__Group_3_1_1__0
+                    // InternalFSM.g:1958:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
+                    // InternalFSM.g:1958:2: rule__InSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3_1_1__0();
@@ -5607,38 +5763,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Alternatives_3_1"
-    // InternalFSM.g:1920:1: rule__OutSemanticsRule__Alternatives_3_1 : ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) );
+    // InternalFSM.g:1967:1: rule__OutSemanticsRule__Alternatives_3_1 : ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) );
     public final void rule__OutSemanticsRule__Alternatives_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1924:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) )
-            int alt14=2;
-            int LA14_0 = input.LA(1);
+            // InternalFSM.g:1971:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) )
+            int alt15=2;
+            int LA15_0 = input.LA(1);
 
-            if ( (LA14_0==58||LA14_0==62) ) {
-                alt14=1;
+            if ( (LA15_0==58||LA15_0==62) ) {
+                alt15=1;
             }
-            else if ( (LA14_0==59) ) {
-                alt14=2;
+            else if ( (LA15_0==59) ) {
+                alt15=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 14, 0, input);
+                    new NoViableAltException("", 15, 0, input);
 
                 throw nvae;
             }
-            switch (alt14) {
+            switch (alt15) {
                 case 1 :
-                    // InternalFSM.g:1925:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalFSM.g:1972:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
                     {
-                    // InternalFSM.g:1925:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
-                    // InternalFSM.g:1926:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalFSM.g:1972:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalFSM.g:1973:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
                     {
                      before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); 
-                    // InternalFSM.g:1927:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
-                    // InternalFSM.g:1927:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
+                    // InternalFSM.g:1974:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalFSM.g:1974:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -5656,14 +5812,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1931:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalFSM.g:1978:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
                     {
-                    // InternalFSM.g:1931:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
-                    // InternalFSM.g:1932:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
+                    // InternalFSM.g:1978:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalFSM.g:1979:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
                     {
                      before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); 
-                    // InternalFSM.g:1933:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
-                    // InternalFSM.g:1933:2: rule__OutSemanticsRule__Group_3_1_1__0
+                    // InternalFSM.g:1980:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
+                    // InternalFSM.g:1980:2: rule__OutSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3_1_1__0();
@@ -5698,120 +5854,120 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationAttribute__Alternatives"
-    // InternalFSM.g:1943:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) );
+    // InternalFSM.g:1990:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) );
     public final void rule__AnnotationAttribute__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1947:1: ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) )
-            int alt15=2;
-            int LA15_0 = input.LA(1);
+            // InternalFSM.g:1994:1: ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) )
+            int alt16=2;
+            int LA16_0 = input.LA(1);
 
-            if ( (LA15_0==71) ) {
-                int LA15_1 = input.LA(2);
+            if ( (LA16_0==71) ) {
+                int LA16_1 = input.LA(2);
 
-                if ( (LA15_1==64) ) {
-                    int LA15_3 = input.LA(3);
+                if ( (LA16_1==64) ) {
+                    int LA16_3 = input.LA(3);
 
-                    if ( (LA15_3==RULE_ID) ) {
-                        int LA15_4 = input.LA(4);
+                    if ( (LA16_3==RULE_ID) ) {
+                        int LA16_4 = input.LA(4);
 
-                        if ( (LA15_4==43) ) {
-                            int LA15_5 = input.LA(5);
+                        if ( (LA16_4==43) ) {
+                            int LA16_5 = input.LA(5);
 
-                            if ( ((LA15_5>=23 && LA15_5<=26)) ) {
-                                alt15=1;
+                            if ( ((LA16_5>=23 && LA16_5<=26)) ) {
+                                alt16=1;
                             }
-                            else if ( (LA15_5==29) ) {
-                                alt15=2;
+                            else if ( (LA16_5==29) ) {
+                                alt16=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 15, 5, input);
+                                    new NoViableAltException("", 16, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 15, 4, input);
+                                new NoViableAltException("", 16, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 15, 3, input);
+                            new NoViableAltException("", 16, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 15, 1, input);
+                        new NoViableAltException("", 16, 1, input);
 
                     throw nvae;
                 }
             }
-            else if ( (LA15_0==13) ) {
-                int LA15_2 = input.LA(2);
+            else if ( (LA16_0==13) ) {
+                int LA16_2 = input.LA(2);
 
-                if ( (LA15_2==64) ) {
-                    int LA15_3 = input.LA(3);
+                if ( (LA16_2==64) ) {
+                    int LA16_3 = input.LA(3);
 
-                    if ( (LA15_3==RULE_ID) ) {
-                        int LA15_4 = input.LA(4);
+                    if ( (LA16_3==RULE_ID) ) {
+                        int LA16_4 = input.LA(4);
 
-                        if ( (LA15_4==43) ) {
-                            int LA15_5 = input.LA(5);
+                        if ( (LA16_4==43) ) {
+                            int LA16_5 = input.LA(5);
 
-                            if ( ((LA15_5>=23 && LA15_5<=26)) ) {
-                                alt15=1;
+                            if ( ((LA16_5>=23 && LA16_5<=26)) ) {
+                                alt16=1;
                             }
-                            else if ( (LA15_5==29) ) {
-                                alt15=2;
+                            else if ( (LA16_5==29) ) {
+                                alt16=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 15, 5, input);
+                                    new NoViableAltException("", 16, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 15, 4, input);
+                                new NoViableAltException("", 16, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 15, 3, input);
+                            new NoViableAltException("", 16, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 15, 2, input);
+                        new NoViableAltException("", 16, 2, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 15, 0, input);
+                    new NoViableAltException("", 16, 0, input);
 
                 throw nvae;
             }
-            switch (alt15) {
+            switch (alt16) {
                 case 1 :
-                    // InternalFSM.g:1948:1: ( ruleSimpleAnnotationAttribute )
+                    // InternalFSM.g:1995:1: ( ruleSimpleAnnotationAttribute )
                     {
-                    // InternalFSM.g:1948:1: ( ruleSimpleAnnotationAttribute )
-                    // InternalFSM.g:1949:1: ruleSimpleAnnotationAttribute
+                    // InternalFSM.g:1995:1: ( ruleSimpleAnnotationAttribute )
+                    // InternalFSM.g:1996:1: ruleSimpleAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -5827,10 +5983,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1954:6: ( ruleEnumAnnotationAttribute )
+                    // InternalFSM.g:2001:6: ( ruleEnumAnnotationAttribute )
                     {
-                    // InternalFSM.g:1954:6: ( ruleEnumAnnotationAttribute )
-                    // InternalFSM.g:1955:1: ruleEnumAnnotationAttribute
+                    // InternalFSM.g:2001:6: ( ruleEnumAnnotationAttribute )
+                    // InternalFSM.g:2002:1: ruleEnumAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -5863,38 +6019,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Alternatives_0"
-    // InternalFSM.g:1965:1: rule__SimpleAnnotationAttribute__Alternatives_0 : ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
+    // InternalFSM.g:2012:1: rule__SimpleAnnotationAttribute__Alternatives_0 : ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
     public final void rule__SimpleAnnotationAttribute__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1969:1: ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
-            int alt16=2;
-            int LA16_0 = input.LA(1);
+            // InternalFSM.g:2016:1: ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
+            int alt17=2;
+            int LA17_0 = input.LA(1);
 
-            if ( (LA16_0==71) ) {
-                alt16=1;
+            if ( (LA17_0==71) ) {
+                alt17=1;
             }
-            else if ( (LA16_0==13) ) {
-                alt16=2;
+            else if ( (LA17_0==13) ) {
+                alt17=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 16, 0, input);
+                    new NoViableAltException("", 17, 0, input);
 
                 throw nvae;
             }
-            switch (alt16) {
+            switch (alt17) {
                 case 1 :
-                    // InternalFSM.g:1970:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalFSM.g:2017:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
                     {
-                    // InternalFSM.g:1970:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
-                    // InternalFSM.g:1971:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalFSM.g:2017:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalFSM.g:2018:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
                     {
                      before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); 
-                    // InternalFSM.g:1972:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
-                    // InternalFSM.g:1972:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
+                    // InternalFSM.g:2019:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalFSM.g:2019:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleAnnotationAttribute__OptionalAssignment_0_0();
@@ -5912,10 +6068,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1976:6: ( 'mandatory' )
+                    // InternalFSM.g:2023:6: ( 'mandatory' )
                     {
-                    // InternalFSM.g:1976:6: ( 'mandatory' )
-                    // InternalFSM.g:1977:1: 'mandatory'
+                    // InternalFSM.g:2023:6: ( 'mandatory' )
+                    // InternalFSM.g:2024:1: 'mandatory'
                     {
                      before(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,13,FOLLOW_2); 
@@ -5944,38 +6100,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Alternatives_0"
-    // InternalFSM.g:1989:1: rule__EnumAnnotationAttribute__Alternatives_0 : ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
+    // InternalFSM.g:2036:1: rule__EnumAnnotationAttribute__Alternatives_0 : ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
     public final void rule__EnumAnnotationAttribute__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:1993:1: ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
-            int alt17=2;
-            int LA17_0 = input.LA(1);
+            // InternalFSM.g:2040:1: ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
+            int alt18=2;
+            int LA18_0 = input.LA(1);
 
-            if ( (LA17_0==71) ) {
-                alt17=1;
+            if ( (LA18_0==71) ) {
+                alt18=1;
             }
-            else if ( (LA17_0==13) ) {
-                alt17=2;
+            else if ( (LA18_0==13) ) {
+                alt18=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 17, 0, input);
+                    new NoViableAltException("", 18, 0, input);
 
                 throw nvae;
             }
-            switch (alt17) {
+            switch (alt18) {
                 case 1 :
-                    // InternalFSM.g:1994:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalFSM.g:2041:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
                     {
-                    // InternalFSM.g:1994:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
-                    // InternalFSM.g:1995:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalFSM.g:2041:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalFSM.g:2042:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
                     {
                      before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); 
-                    // InternalFSM.g:1996:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
-                    // InternalFSM.g:1996:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0
+                    // InternalFSM.g:2043:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalFSM.g:2043:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumAnnotationAttribute__OptionalAssignment_0_0();
@@ -5993,10 +6149,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2000:6: ( 'mandatory' )
+                    // InternalFSM.g:2047:6: ( 'mandatory' )
                     {
-                    // InternalFSM.g:2000:6: ( 'mandatory' )
-                    // InternalFSM.g:2001:1: 'mandatory'
+                    // InternalFSM.g:2047:6: ( 'mandatory' )
+                    // InternalFSM.g:2048:1: 'mandatory'
                     {
                      before(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,13,FOLLOW_2); 
@@ -6025,19 +6181,19 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Literal__Alternatives"
-    // InternalFSM.g:2015:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) );
+    // InternalFSM.g:2062:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) );
     public final void rule__Literal__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2019:1: ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) )
-            int alt18=3;
+            // InternalFSM.g:2066:1: ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) )
+            int alt19=3;
             switch ( input.LA(1) ) {
             case 14:
             case 72:
                 {
-                alt18=1;
+                alt19=1;
                 }
                 break;
             case RULE_HEX:
@@ -6045,27 +6201,27 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             case 15:
             case 16:
                 {
-                alt18=2;
+                alt19=2;
                 }
                 break;
             case RULE_STRING:
                 {
-                alt18=3;
+                alt19=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 18, 0, input);
+                    new NoViableAltException("", 19, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt18) {
+            switch (alt19) {
                 case 1 :
-                    // InternalFSM.g:2020:1: ( ruleBooleanLiteral )
+                    // InternalFSM.g:2067:1: ( ruleBooleanLiteral )
                     {
-                    // InternalFSM.g:2020:1: ( ruleBooleanLiteral )
-                    // InternalFSM.g:2021:1: ruleBooleanLiteral
+                    // InternalFSM.g:2067:1: ( ruleBooleanLiteral )
+                    // InternalFSM.g:2068:1: ruleBooleanLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -6081,10 +6237,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2026:6: ( ruleNumberLiteral )
+                    // InternalFSM.g:2073:6: ( ruleNumberLiteral )
                     {
-                    // InternalFSM.g:2026:6: ( ruleNumberLiteral )
-                    // InternalFSM.g:2027:1: ruleNumberLiteral
+                    // InternalFSM.g:2073:6: ( ruleNumberLiteral )
+                    // InternalFSM.g:2074:1: ruleNumberLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -6100,10 +6256,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:2032:6: ( ruleStringLiteral )
+                    // InternalFSM.g:2079:6: ( ruleStringLiteral )
                     {
-                    // InternalFSM.g:2032:6: ( ruleStringLiteral )
-                    // InternalFSM.g:2033:1: ruleStringLiteral
+                    // InternalFSM.g:2079:6: ( ruleStringLiteral )
+                    // InternalFSM.g:2080:1: ruleStringLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -6136,34 +6292,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Alternatives_1"
-    // InternalFSM.g:2043:1: rule__BooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) );
+    // InternalFSM.g:2090:1: rule__BooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) );
     public final void rule__BooleanLiteral__Alternatives_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2047:1: ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) )
-            int alt19=2;
-            int LA19_0 = input.LA(1);
+            // InternalFSM.g:2094:1: ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) )
+            int alt20=2;
+            int LA20_0 = input.LA(1);
 
-            if ( (LA19_0==14) ) {
-                alt19=1;
+            if ( (LA20_0==14) ) {
+                alt20=1;
             }
-            else if ( (LA19_0==72) ) {
-                alt19=2;
+            else if ( (LA20_0==72) ) {
+                alt20=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 19, 0, input);
+                    new NoViableAltException("", 20, 0, input);
 
                 throw nvae;
             }
-            switch (alt19) {
+            switch (alt20) {
                 case 1 :
-                    // InternalFSM.g:2048:1: ( 'false' )
+                    // InternalFSM.g:2095:1: ( 'false' )
                     {
-                    // InternalFSM.g:2048:1: ( 'false' )
-                    // InternalFSM.g:2049:1: 'false'
+                    // InternalFSM.g:2095:1: ( 'false' )
+                    // InternalFSM.g:2096:1: 'false'
                     {
                      before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); 
                     match(input,14,FOLLOW_2); 
@@ -6175,14 +6331,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2056:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalFSM.g:2103:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
                     {
-                    // InternalFSM.g:2056:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
-                    // InternalFSM.g:2057:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalFSM.g:2103:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalFSM.g:2104:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
                     {
                      before(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); 
-                    // InternalFSM.g:2058:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
-                    // InternalFSM.g:2058:2: rule__BooleanLiteral__IsTrueAssignment_1_1
+                    // InternalFSM.g:2105:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalFSM.g:2105:2: rule__BooleanLiteral__IsTrueAssignment_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__BooleanLiteral__IsTrueAssignment_1_1();
@@ -6217,38 +6373,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NumberLiteral__Alternatives"
-    // InternalFSM.g:2067:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) );
+    // InternalFSM.g:2114:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) );
     public final void rule__NumberLiteral__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2071:1: ( ( ruleIntLiteral ) | ( ruleRealLiteral ) )
-            int alt20=2;
+            // InternalFSM.g:2118:1: ( ( ruleIntLiteral ) | ( ruleRealLiteral ) )
+            int alt21=2;
             switch ( input.LA(1) ) {
             case 15:
                 {
-                int LA20_1 = input.LA(2);
+                int LA21_1 = input.LA(2);
 
-                if ( (LA20_1==RULE_INT) ) {
-                    int LA20_3 = input.LA(3);
+                if ( (LA21_1==RULE_INT) ) {
+                    int LA21_3 = input.LA(3);
 
-                    if ( (LA20_3==68) ) {
-                        alt20=2;
+                    if ( (LA21_3==EOF) ) {
+                        alt21=1;
                     }
-                    else if ( (LA20_3==EOF) ) {
-                        alt20=1;
+                    else if ( (LA21_3==68) ) {
+                        alt21=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 20, 3, input);
+                            new NoViableAltException("", 21, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 20, 1, input);
+                        new NoViableAltException("", 21, 1, input);
 
                     throw nvae;
                 }
@@ -6256,27 +6412,27 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case 16:
                 {
-                int LA20_2 = input.LA(2);
+                int LA21_2 = input.LA(2);
 
-                if ( (LA20_2==RULE_INT) ) {
-                    int LA20_3 = input.LA(3);
+                if ( (LA21_2==RULE_INT) ) {
+                    int LA21_3 = input.LA(3);
 
-                    if ( (LA20_3==68) ) {
-                        alt20=2;
+                    if ( (LA21_3==EOF) ) {
+                        alt21=1;
                     }
-                    else if ( (LA20_3==EOF) ) {
-                        alt20=1;
+                    else if ( (LA21_3==68) ) {
+                        alt21=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 20, 3, input);
+                            new NoViableAltException("", 21, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 20, 2, input);
+                        new NoViableAltException("", 21, 2, input);
 
                     throw nvae;
                 }
@@ -6284,17 +6440,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_INT:
                 {
-                int LA20_3 = input.LA(2);
+                int LA21_3 = input.LA(2);
 
-                if ( (LA20_3==68) ) {
-                    alt20=2;
+                if ( (LA21_3==EOF) ) {
+                    alt21=1;
                 }
-                else if ( (LA20_3==EOF) ) {
-                    alt20=1;
+                else if ( (LA21_3==68) ) {
+                    alt21=2;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 20, 3, input);
+                        new NoViableAltException("", 21, 3, input);
 
                     throw nvae;
                 }
@@ -6302,22 +6458,22 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_HEX:
                 {
-                alt20=1;
+                alt21=1;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 20, 0, input);
+                    new NoViableAltException("", 21, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt20) {
+            switch (alt21) {
                 case 1 :
-                    // InternalFSM.g:2072:1: ( ruleIntLiteral )
+                    // InternalFSM.g:2119:1: ( ruleIntLiteral )
                     {
-                    // InternalFSM.g:2072:1: ( ruleIntLiteral )
-                    // InternalFSM.g:2073:1: ruleIntLiteral
+                    // InternalFSM.g:2119:1: ( ruleIntLiteral )
+                    // InternalFSM.g:2120:1: ruleIntLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -6333,10 +6489,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2078:6: ( ruleRealLiteral )
+                    // InternalFSM.g:2125:6: ( ruleRealLiteral )
                     {
-                    // InternalFSM.g:2078:6: ( ruleRealLiteral )
-                    // InternalFSM.g:2079:1: ruleRealLiteral
+                    // InternalFSM.g:2125:6: ( ruleRealLiteral )
+                    // InternalFSM.g:2126:1: ruleRealLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -6369,38 +6525,38 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Alternatives"
-    // InternalFSM.g:2089:1: rule__Integer__Alternatives : ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) );
+    // InternalFSM.g:2136:1: rule__Integer__Alternatives : ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) );
     public final void rule__Integer__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2093:1: ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) )
-            int alt21=2;
-            int LA21_0 = input.LA(1);
+            // InternalFSM.g:2140:1: ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) )
+            int alt22=2;
+            int LA22_0 = input.LA(1);
 
-            if ( (LA21_0==RULE_INT||(LA21_0>=15 && LA21_0<=16)) ) {
-                alt21=1;
+            if ( (LA22_0==RULE_INT||(LA22_0>=15 && LA22_0<=16)) ) {
+                alt22=1;
             }
-            else if ( (LA21_0==RULE_HEX) ) {
-                alt21=2;
+            else if ( (LA22_0==RULE_HEX) ) {
+                alt22=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 21, 0, input);
+                    new NoViableAltException("", 22, 0, input);
 
                 throw nvae;
             }
-            switch (alt21) {
+            switch (alt22) {
                 case 1 :
-                    // InternalFSM.g:2094:1: ( ( rule__Integer__Group_0__0 ) )
+                    // InternalFSM.g:2141:1: ( ( rule__Integer__Group_0__0 ) )
                     {
-                    // InternalFSM.g:2094:1: ( ( rule__Integer__Group_0__0 ) )
-                    // InternalFSM.g:2095:1: ( rule__Integer__Group_0__0 )
+                    // InternalFSM.g:2141:1: ( ( rule__Integer__Group_0__0 ) )
+                    // InternalFSM.g:2142:1: ( rule__Integer__Group_0__0 )
                     {
                      before(grammarAccess.getIntegerAccess().getGroup_0()); 
-                    // InternalFSM.g:2096:1: ( rule__Integer__Group_0__0 )
-                    // InternalFSM.g:2096:2: rule__Integer__Group_0__0
+                    // InternalFSM.g:2143:1: ( rule__Integer__Group_0__0 )
+                    // InternalFSM.g:2143:2: rule__Integer__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Group_0__0();
@@ -6418,10 +6574,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2100:6: ( RULE_HEX )
+                    // InternalFSM.g:2147:6: ( RULE_HEX )
                     {
-                    // InternalFSM.g:2100:6: ( RULE_HEX )
-                    // InternalFSM.g:2101:1: RULE_HEX
+                    // InternalFSM.g:2147:6: ( RULE_HEX )
+                    // InternalFSM.g:2148:1: RULE_HEX
                     {
                      before(grammarAccess.getIntegerAccess().getHEXTerminalRuleCall_1()); 
                     match(input,RULE_HEX,FOLLOW_2); 
@@ -6450,34 +6606,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Alternatives_0_0"
-    // InternalFSM.g:2111:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) );
+    // InternalFSM.g:2158:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__Integer__Alternatives_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2115:1: ( ( '+' ) | ( '-' ) )
-            int alt22=2;
-            int LA22_0 = input.LA(1);
+            // InternalFSM.g:2162:1: ( ( '+' ) | ( '-' ) )
+            int alt23=2;
+            int LA23_0 = input.LA(1);
 
-            if ( (LA22_0==15) ) {
-                alt22=1;
+            if ( (LA23_0==15) ) {
+                alt23=1;
             }
-            else if ( (LA22_0==16) ) {
-                alt22=2;
+            else if ( (LA23_0==16) ) {
+                alt23=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 22, 0, input);
+                    new NoViableAltException("", 23, 0, input);
 
                 throw nvae;
             }
-            switch (alt22) {
+            switch (alt23) {
                 case 1 :
-                    // InternalFSM.g:2116:1: ( '+' )
+                    // InternalFSM.g:2163:1: ( '+' )
                     {
-                    // InternalFSM.g:2116:1: ( '+' )
-                    // InternalFSM.g:2117:1: '+'
+                    // InternalFSM.g:2163:1: ( '+' )
+                    // InternalFSM.g:2164:1: '+'
                     {
                      before(grammarAccess.getIntegerAccess().getPlusSignKeyword_0_0_0()); 
                     match(input,15,FOLLOW_2); 
@@ -6489,10 +6645,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2124:6: ( '-' )
+                    // InternalFSM.g:2171:6: ( '-' )
                     {
-                    // InternalFSM.g:2124:6: ( '-' )
-                    // InternalFSM.g:2125:1: '-'
+                    // InternalFSM.g:2171:6: ( '-' )
+                    // InternalFSM.g:2172:1: '-'
                     {
                      before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0_0_1()); 
                     match(input,16,FOLLOW_2); 
@@ -6521,58 +6677,58 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Real__Alternatives"
-    // InternalFSM.g:2137:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) );
+    // InternalFSM.g:2184:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) );
     public final void rule__Real__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2141:1: ( ( ruleDecimal ) | ( ruleDecimalExp ) )
-            int alt23=2;
+            // InternalFSM.g:2188:1: ( ( ruleDecimal ) | ( ruleDecimalExp ) )
+            int alt24=2;
             switch ( input.LA(1) ) {
             case 15:
                 {
-                int LA23_1 = input.LA(2);
+                int LA24_1 = input.LA(2);
 
-                if ( (LA23_1==RULE_INT) ) {
-                    int LA23_3 = input.LA(3);
+                if ( (LA24_1==RULE_INT) ) {
+                    int LA24_3 = input.LA(3);
 
-                    if ( (LA23_3==68) ) {
-                        int LA23_4 = input.LA(4);
+                    if ( (LA24_3==68) ) {
+                        int LA24_4 = input.LA(4);
 
-                        if ( (LA23_4==RULE_INT) ) {
-                            int LA23_5 = input.LA(5);
+                        if ( (LA24_4==RULE_INT) ) {
+                            int LA24_5 = input.LA(5);
 
-                            if ( (LA23_5==EOF) ) {
-                                alt23=1;
+                            if ( ((LA24_5>=17 && LA24_5<=18)) ) {
+                                alt24=2;
                             }
-                            else if ( ((LA23_5>=17 && LA23_5<=18)) ) {
-                                alt23=2;
+                            else if ( (LA24_5==EOF) ) {
+                                alt24=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 23, 5, input);
+                                    new NoViableAltException("", 24, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 23, 4, input);
+                                new NoViableAltException("", 24, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 23, 3, input);
+                            new NoViableAltException("", 24, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 23, 1, input);
+                        new NoViableAltException("", 24, 1, input);
 
                     throw nvae;
                 }
@@ -6580,47 +6736,47 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case 16:
                 {
-                int LA23_2 = input.LA(2);
+                int LA24_2 = input.LA(2);
 
-                if ( (LA23_2==RULE_INT) ) {
-                    int LA23_3 = input.LA(3);
+                if ( (LA24_2==RULE_INT) ) {
+                    int LA24_3 = input.LA(3);
 
-                    if ( (LA23_3==68) ) {
-                        int LA23_4 = input.LA(4);
+                    if ( (LA24_3==68) ) {
+                        int LA24_4 = input.LA(4);
 
-                        if ( (LA23_4==RULE_INT) ) {
-                            int LA23_5 = input.LA(5);
+                        if ( (LA24_4==RULE_INT) ) {
+                            int LA24_5 = input.LA(5);
 
-                            if ( (LA23_5==EOF) ) {
-                                alt23=1;
+                            if ( ((LA24_5>=17 && LA24_5<=18)) ) {
+                                alt24=2;
                             }
-                            else if ( ((LA23_5>=17 && LA23_5<=18)) ) {
-                                alt23=2;
+                            else if ( (LA24_5==EOF) ) {
+                                alt24=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 23, 5, input);
+                                    new NoViableAltException("", 24, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 23, 4, input);
+                                new NoViableAltException("", 24, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 23, 3, input);
+                            new NoViableAltException("", 24, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 23, 2, input);
+                        new NoViableAltException("", 24, 2, input);
 
                     throw nvae;
                 }
@@ -6628,37 +6784,37 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_INT:
                 {
-                int LA23_3 = input.LA(2);
+                int LA24_3 = input.LA(2);
 
-                if ( (LA23_3==68) ) {
-                    int LA23_4 = input.LA(3);
+                if ( (LA24_3==68) ) {
+                    int LA24_4 = input.LA(3);
 
-                    if ( (LA23_4==RULE_INT) ) {
-                        int LA23_5 = input.LA(4);
+                    if ( (LA24_4==RULE_INT) ) {
+                        int LA24_5 = input.LA(4);
 
-                        if ( (LA23_5==EOF) ) {
-                            alt23=1;
+                        if ( ((LA24_5>=17 && LA24_5<=18)) ) {
+                            alt24=2;
                         }
-                        else if ( ((LA23_5>=17 && LA23_5<=18)) ) {
-                            alt23=2;
+                        else if ( (LA24_5==EOF) ) {
+                            alt24=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 23, 5, input);
+                                new NoViableAltException("", 24, 5, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 23, 4, input);
+                            new NoViableAltException("", 24, 4, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 23, 3, input);
+                        new NoViableAltException("", 24, 3, input);
 
                     throw nvae;
                 }
@@ -6666,17 +6822,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 23, 0, input);
+                    new NoViableAltException("", 24, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt23) {
+            switch (alt24) {
                 case 1 :
-                    // InternalFSM.g:2142:1: ( ruleDecimal )
+                    // InternalFSM.g:2189:1: ( ruleDecimal )
                     {
-                    // InternalFSM.g:2142:1: ( ruleDecimal )
-                    // InternalFSM.g:2143:1: ruleDecimal
+                    // InternalFSM.g:2189:1: ( ruleDecimal )
+                    // InternalFSM.g:2190:1: ruleDecimal
                     {
                      before(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -6692,10 +6848,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2148:6: ( ruleDecimalExp )
+                    // InternalFSM.g:2195:6: ( ruleDecimalExp )
                     {
-                    // InternalFSM.g:2148:6: ( ruleDecimalExp )
-                    // InternalFSM.g:2149:1: ruleDecimalExp
+                    // InternalFSM.g:2195:6: ( ruleDecimalExp )
+                    // InternalFSM.g:2196:1: ruleDecimalExp
                     {
                      before(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -6728,34 +6884,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Alternatives_0"
-    // InternalFSM.g:2159:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalFSM.g:2206:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__Decimal__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2163:1: ( ( '+' ) | ( '-' ) )
-            int alt24=2;
-            int LA24_0 = input.LA(1);
+            // InternalFSM.g:2210:1: ( ( '+' ) | ( '-' ) )
+            int alt25=2;
+            int LA25_0 = input.LA(1);
 
-            if ( (LA24_0==15) ) {
-                alt24=1;
+            if ( (LA25_0==15) ) {
+                alt25=1;
             }
-            else if ( (LA24_0==16) ) {
-                alt24=2;
+            else if ( (LA25_0==16) ) {
+                alt25=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 24, 0, input);
+                    new NoViableAltException("", 25, 0, input);
 
                 throw nvae;
             }
-            switch (alt24) {
+            switch (alt25) {
                 case 1 :
-                    // InternalFSM.g:2164:1: ( '+' )
+                    // InternalFSM.g:2211:1: ( '+' )
                     {
-                    // InternalFSM.g:2164:1: ( '+' )
-                    // InternalFSM.g:2165:1: '+'
+                    // InternalFSM.g:2211:1: ( '+' )
+                    // InternalFSM.g:2212:1: '+'
                     {
                      before(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); 
                     match(input,15,FOLLOW_2); 
@@ -6767,10 +6923,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2172:6: ( '-' )
+                    // InternalFSM.g:2219:6: ( '-' )
                     {
-                    // InternalFSM.g:2172:6: ( '-' )
-                    // InternalFSM.g:2173:1: '-'
+                    // InternalFSM.g:2219:6: ( '-' )
+                    // InternalFSM.g:2220:1: '-'
                     {
                      before(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,16,FOLLOW_2); 
@@ -6799,34 +6955,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_0"
-    // InternalFSM.g:2185:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalFSM.g:2232:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__DecimalExp__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2189:1: ( ( '+' ) | ( '-' ) )
-            int alt25=2;
-            int LA25_0 = input.LA(1);
+            // InternalFSM.g:2236:1: ( ( '+' ) | ( '-' ) )
+            int alt26=2;
+            int LA26_0 = input.LA(1);
 
-            if ( (LA25_0==15) ) {
-                alt25=1;
+            if ( (LA26_0==15) ) {
+                alt26=1;
             }
-            else if ( (LA25_0==16) ) {
-                alt25=2;
+            else if ( (LA26_0==16) ) {
+                alt26=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 25, 0, input);
+                    new NoViableAltException("", 26, 0, input);
 
                 throw nvae;
             }
-            switch (alt25) {
+            switch (alt26) {
                 case 1 :
-                    // InternalFSM.g:2190:1: ( '+' )
+                    // InternalFSM.g:2237:1: ( '+' )
                     {
-                    // InternalFSM.g:2190:1: ( '+' )
-                    // InternalFSM.g:2191:1: '+'
+                    // InternalFSM.g:2237:1: ( '+' )
+                    // InternalFSM.g:2238:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); 
                     match(input,15,FOLLOW_2); 
@@ -6838,10 +6994,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2198:6: ( '-' )
+                    // InternalFSM.g:2245:6: ( '-' )
                     {
-                    // InternalFSM.g:2198:6: ( '-' )
-                    // InternalFSM.g:2199:1: '-'
+                    // InternalFSM.g:2245:6: ( '-' )
+                    // InternalFSM.g:2246:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,16,FOLLOW_2); 
@@ -6870,34 +7026,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_4"
-    // InternalFSM.g:2211:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) );
+    // InternalFSM.g:2258:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) );
     public final void rule__DecimalExp__Alternatives_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2215:1: ( ( 'e' ) | ( 'E' ) )
-            int alt26=2;
-            int LA26_0 = input.LA(1);
+            // InternalFSM.g:2262:1: ( ( 'e' ) | ( 'E' ) )
+            int alt27=2;
+            int LA27_0 = input.LA(1);
 
-            if ( (LA26_0==17) ) {
-                alt26=1;
+            if ( (LA27_0==17) ) {
+                alt27=1;
             }
-            else if ( (LA26_0==18) ) {
-                alt26=2;
+            else if ( (LA27_0==18) ) {
+                alt27=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 26, 0, input);
+                    new NoViableAltException("", 27, 0, input);
 
                 throw nvae;
             }
-            switch (alt26) {
+            switch (alt27) {
                 case 1 :
-                    // InternalFSM.g:2216:1: ( 'e' )
+                    // InternalFSM.g:2263:1: ( 'e' )
                     {
-                    // InternalFSM.g:2216:1: ( 'e' )
-                    // InternalFSM.g:2217:1: 'e'
+                    // InternalFSM.g:2263:1: ( 'e' )
+                    // InternalFSM.g:2264:1: 'e'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); 
                     match(input,17,FOLLOW_2); 
@@ -6909,10 +7065,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2224:6: ( 'E' )
+                    // InternalFSM.g:2271:6: ( 'E' )
                     {
-                    // InternalFSM.g:2224:6: ( 'E' )
-                    // InternalFSM.g:2225:1: 'E'
+                    // InternalFSM.g:2271:6: ( 'E' )
+                    // InternalFSM.g:2272:1: 'E'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); 
                     match(input,18,FOLLOW_2); 
@@ -6941,34 +7097,34 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_5"
-    // InternalFSM.g:2237:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) );
+    // InternalFSM.g:2284:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) );
     public final void rule__DecimalExp__Alternatives_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2241:1: ( ( '+' ) | ( '-' ) )
-            int alt27=2;
-            int LA27_0 = input.LA(1);
+            // InternalFSM.g:2288:1: ( ( '+' ) | ( '-' ) )
+            int alt28=2;
+            int LA28_0 = input.LA(1);
 
-            if ( (LA27_0==15) ) {
-                alt27=1;
+            if ( (LA28_0==15) ) {
+                alt28=1;
             }
-            else if ( (LA27_0==16) ) {
-                alt27=2;
+            else if ( (LA28_0==16) ) {
+                alt28=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 27, 0, input);
+                    new NoViableAltException("", 28, 0, input);
 
                 throw nvae;
             }
-            switch (alt27) {
+            switch (alt28) {
                 case 1 :
-                    // InternalFSM.g:2242:1: ( '+' )
+                    // InternalFSM.g:2289:1: ( '+' )
                     {
-                    // InternalFSM.g:2242:1: ( '+' )
-                    // InternalFSM.g:2243:1: '+'
+                    // InternalFSM.g:2289:1: ( '+' )
+                    // InternalFSM.g:2290:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_5_0()); 
                     match(input,15,FOLLOW_2); 
@@ -6980,10 +7136,10 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2250:6: ( '-' )
+                    // InternalFSM.g:2297:6: ( '-' )
                     {
-                    // InternalFSM.g:2250:6: ( '-' )
-                    // InternalFSM.g:2251:1: '-'
+                    // InternalFSM.g:2297:6: ( '-' )
+                    // InternalFSM.g:2298:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_5_1()); 
                     match(input,16,FOLLOW_2); 
@@ -7012,52 +7168,52 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ComponentCommunicationType__Alternatives"
-    // InternalFSM.g:2263:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) );
+    // InternalFSM.g:2310:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) );
     public final void rule__ComponentCommunicationType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2267:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) )
-            int alt28=4;
+            // InternalFSM.g:2314:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) )
+            int alt29=4;
             switch ( input.LA(1) ) {
             case 19:
                 {
-                alt28=1;
+                alt29=1;
                 }
                 break;
             case 20:
                 {
-                alt28=2;
+                alt29=2;
                 }
                 break;
             case 21:
                 {
-                alt28=3;
+                alt29=3;
                 }
                 break;
             case 22:
                 {
-                alt28=4;
+                alt29=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 28, 0, input);
+                    new NoViableAltException("", 29, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt28) {
+            switch (alt29) {
                 case 1 :
-                    // InternalFSM.g:2268:1: ( ( 'eventdriven' ) )
+                    // InternalFSM.g:2315:1: ( ( 'eventdriven' ) )
                     {
-                    // InternalFSM.g:2268:1: ( ( 'eventdriven' ) )
-                    // InternalFSM.g:2269:1: ( 'eventdriven' )
+                    // InternalFSM.g:2315:1: ( ( 'eventdriven' ) )
+                    // InternalFSM.g:2316:1: ( 'eventdriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); 
-                    // InternalFSM.g:2270:1: ( 'eventdriven' )
-                    // InternalFSM.g:2270:3: 'eventdriven'
+                    // InternalFSM.g:2317:1: ( 'eventdriven' )
+                    // InternalFSM.g:2317:3: 'eventdriven'
                     {
                     match(input,19,FOLLOW_2); 
 
@@ -7071,14 +7227,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2275:6: ( ( 'datadriven' ) )
+                    // InternalFSM.g:2322:6: ( ( 'datadriven' ) )
                     {
-                    // InternalFSM.g:2275:6: ( ( 'datadriven' ) )
-                    // InternalFSM.g:2276:1: ( 'datadriven' )
+                    // InternalFSM.g:2322:6: ( ( 'datadriven' ) )
+                    // InternalFSM.g:2323:1: ( 'datadriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); 
-                    // InternalFSM.g:2277:1: ( 'datadriven' )
-                    // InternalFSM.g:2277:3: 'datadriven'
+                    // InternalFSM.g:2324:1: ( 'datadriven' )
+                    // InternalFSM.g:2324:3: 'datadriven'
                     {
                     match(input,20,FOLLOW_2); 
 
@@ -7092,14 +7248,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:2282:6: ( ( 'async' ) )
+                    // InternalFSM.g:2329:6: ( ( 'async' ) )
                     {
-                    // InternalFSM.g:2282:6: ( ( 'async' ) )
-                    // InternalFSM.g:2283:1: ( 'async' )
+                    // InternalFSM.g:2329:6: ( ( 'async' ) )
+                    // InternalFSM.g:2330:1: ( 'async' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); 
-                    // InternalFSM.g:2284:1: ( 'async' )
-                    // InternalFSM.g:2284:3: 'async'
+                    // InternalFSM.g:2331:1: ( 'async' )
+                    // InternalFSM.g:2331:3: 'async'
                     {
                     match(input,21,FOLLOW_2); 
 
@@ -7113,14 +7269,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:2289:6: ( ( 'sync' ) )
+                    // InternalFSM.g:2336:6: ( ( 'sync' ) )
                     {
-                    // InternalFSM.g:2289:6: ( ( 'sync' ) )
-                    // InternalFSM.g:2290:1: ( 'sync' )
+                    // InternalFSM.g:2336:6: ( ( 'sync' ) )
+                    // InternalFSM.g:2337:1: ( 'sync' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); 
-                    // InternalFSM.g:2291:1: ( 'sync' )
-                    // InternalFSM.g:2291:3: 'sync'
+                    // InternalFSM.g:2338:1: ( 'sync' )
+                    // InternalFSM.g:2338:3: 'sync'
                     {
                     match(input,22,FOLLOW_2); 
 
@@ -7151,52 +7307,52 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LiteralType__Alternatives"
-    // InternalFSM.g:2301:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) );
+    // InternalFSM.g:2348:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) );
     public final void rule__LiteralType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2305:1: ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) )
-            int alt29=4;
+            // InternalFSM.g:2352:1: ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) )
+            int alt30=4;
             switch ( input.LA(1) ) {
             case 23:
                 {
-                alt29=1;
+                alt30=1;
                 }
                 break;
             case 24:
                 {
-                alt29=2;
+                alt30=2;
                 }
                 break;
             case 25:
                 {
-                alt29=3;
+                alt30=3;
                 }
                 break;
             case 26:
                 {
-                alt29=4;
+                alt30=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 29, 0, input);
+                    new NoViableAltException("", 30, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt29) {
+            switch (alt30) {
                 case 1 :
-                    // InternalFSM.g:2306:1: ( ( 'ptBoolean' ) )
+                    // InternalFSM.g:2353:1: ( ( 'ptBoolean' ) )
                     {
-                    // InternalFSM.g:2306:1: ( ( 'ptBoolean' ) )
-                    // InternalFSM.g:2307:1: ( 'ptBoolean' )
+                    // InternalFSM.g:2353:1: ( ( 'ptBoolean' ) )
+                    // InternalFSM.g:2354:1: ( 'ptBoolean' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); 
-                    // InternalFSM.g:2308:1: ( 'ptBoolean' )
-                    // InternalFSM.g:2308:3: 'ptBoolean'
+                    // InternalFSM.g:2355:1: ( 'ptBoolean' )
+                    // InternalFSM.g:2355:3: 'ptBoolean'
                     {
                     match(input,23,FOLLOW_2); 
 
@@ -7210,14 +7366,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2313:6: ( ( 'ptInteger' ) )
+                    // InternalFSM.g:2360:6: ( ( 'ptInteger' ) )
                     {
-                    // InternalFSM.g:2313:6: ( ( 'ptInteger' ) )
-                    // InternalFSM.g:2314:1: ( 'ptInteger' )
+                    // InternalFSM.g:2360:6: ( ( 'ptInteger' ) )
+                    // InternalFSM.g:2361:1: ( 'ptInteger' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); 
-                    // InternalFSM.g:2315:1: ( 'ptInteger' )
-                    // InternalFSM.g:2315:3: 'ptInteger'
+                    // InternalFSM.g:2362:1: ( 'ptInteger' )
+                    // InternalFSM.g:2362:3: 'ptInteger'
                     {
                     match(input,24,FOLLOW_2); 
 
@@ -7231,14 +7387,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:2320:6: ( ( 'ptReal' ) )
+                    // InternalFSM.g:2367:6: ( ( 'ptReal' ) )
                     {
-                    // InternalFSM.g:2320:6: ( ( 'ptReal' ) )
-                    // InternalFSM.g:2321:1: ( 'ptReal' )
+                    // InternalFSM.g:2367:6: ( ( 'ptReal' ) )
+                    // InternalFSM.g:2368:1: ( 'ptReal' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); 
-                    // InternalFSM.g:2322:1: ( 'ptReal' )
-                    // InternalFSM.g:2322:3: 'ptReal'
+                    // InternalFSM.g:2369:1: ( 'ptReal' )
+                    // InternalFSM.g:2369:3: 'ptReal'
                     {
                     match(input,25,FOLLOW_2); 
 
@@ -7252,14 +7408,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:2327:6: ( ( 'ptCharacter' ) )
+                    // InternalFSM.g:2374:6: ( ( 'ptCharacter' ) )
                     {
-                    // InternalFSM.g:2327:6: ( ( 'ptCharacter' ) )
-                    // InternalFSM.g:2328:1: ( 'ptCharacter' )
+                    // InternalFSM.g:2374:6: ( ( 'ptCharacter' ) )
+                    // InternalFSM.g:2375:1: ( 'ptCharacter' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); 
-                    // InternalFSM.g:2329:1: ( 'ptCharacter' )
-                    // InternalFSM.g:2329:3: 'ptCharacter'
+                    // InternalFSM.g:2376:1: ( 'ptCharacter' )
+                    // InternalFSM.g:2376:3: 'ptCharacter'
                     {
                     match(input,26,FOLLOW_2); 
 
@@ -7290,14 +7446,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__0"
-    // InternalFSM.g:2341:1: rule__ModelComponent__Group__0 : rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 ;
+    // InternalFSM.g:2388:1: rule__ModelComponent__Group__0 : rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 ;
     public final void rule__ModelComponent__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2345:1: ( rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 )
-            // InternalFSM.g:2346:2: rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1
+            // InternalFSM.g:2392:1: ( rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 )
+            // InternalFSM.g:2393:2: rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1
             {
             pushFollow(FOLLOW_4);
             rule__ModelComponent__Group__0__Impl();
@@ -7328,21 +7484,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__0__Impl"
-    // InternalFSM.g:2353:1: rule__ModelComponent__Group__0__Impl : ( ( rule__ModelComponent__UnorderedGroup_0 ) ) ;
+    // InternalFSM.g:2400:1: rule__ModelComponent__Group__0__Impl : ( ( rule__ModelComponent__UnorderedGroup_0 ) ) ;
     public final void rule__ModelComponent__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2357:1: ( ( ( rule__ModelComponent__UnorderedGroup_0 ) ) )
-            // InternalFSM.g:2358:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) )
+            // InternalFSM.g:2404:1: ( ( ( rule__ModelComponent__UnorderedGroup_0 ) ) )
+            // InternalFSM.g:2405:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) )
             {
-            // InternalFSM.g:2358:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) )
-            // InternalFSM.g:2359:1: ( rule__ModelComponent__UnorderedGroup_0 )
+            // InternalFSM.g:2405:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) )
+            // InternalFSM.g:2406:1: ( rule__ModelComponent__UnorderedGroup_0 )
             {
              before(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); 
-            // InternalFSM.g:2360:1: ( rule__ModelComponent__UnorderedGroup_0 )
-            // InternalFSM.g:2360:2: rule__ModelComponent__UnorderedGroup_0
+            // InternalFSM.g:2407:1: ( rule__ModelComponent__UnorderedGroup_0 )
+            // InternalFSM.g:2407:2: rule__ModelComponent__UnorderedGroup_0
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__UnorderedGroup_0();
@@ -7375,14 +7531,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__1"
-    // InternalFSM.g:2370:1: rule__ModelComponent__Group__1 : rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 ;
+    // InternalFSM.g:2417:1: rule__ModelComponent__Group__1 : rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 ;
     public final void rule__ModelComponent__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2374:1: ( rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 )
-            // InternalFSM.g:2375:2: rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2
+            // InternalFSM.g:2421:1: ( rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 )
+            // InternalFSM.g:2422:2: rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__ModelComponent__Group__1__Impl();
@@ -7413,17 +7569,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__1__Impl"
-    // InternalFSM.g:2382:1: rule__ModelComponent__Group__1__Impl : ( 'ModelComponent' ) ;
+    // InternalFSM.g:2429:1: rule__ModelComponent__Group__1__Impl : ( 'ModelComponent' ) ;
     public final void rule__ModelComponent__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2386:1: ( ( 'ModelComponent' ) )
-            // InternalFSM.g:2387:1: ( 'ModelComponent' )
+            // InternalFSM.g:2433:1: ( ( 'ModelComponent' ) )
+            // InternalFSM.g:2434:1: ( 'ModelComponent' )
             {
-            // InternalFSM.g:2387:1: ( 'ModelComponent' )
-            // InternalFSM.g:2388:1: 'ModelComponent'
+            // InternalFSM.g:2434:1: ( 'ModelComponent' )
+            // InternalFSM.g:2435:1: 'ModelComponent'
             {
              before(grammarAccess.getModelComponentAccess().getModelComponentKeyword_1()); 
             match(input,27,FOLLOW_2); 
@@ -7450,14 +7606,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__2"
-    // InternalFSM.g:2401:1: rule__ModelComponent__Group__2 : rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 ;
+    // InternalFSM.g:2448:1: rule__ModelComponent__Group__2 : rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 ;
     public final void rule__ModelComponent__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2405:1: ( rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 )
-            // InternalFSM.g:2406:2: rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3
+            // InternalFSM.g:2452:1: ( rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 )
+            // InternalFSM.g:2453:2: rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3
             {
             pushFollow(FOLLOW_6);
             rule__ModelComponent__Group__2__Impl();
@@ -7488,21 +7644,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__2__Impl"
-    // InternalFSM.g:2413:1: rule__ModelComponent__Group__2__Impl : ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) ;
+    // InternalFSM.g:2460:1: rule__ModelComponent__Group__2__Impl : ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) ;
     public final void rule__ModelComponent__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2417:1: ( ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) )
-            // InternalFSM.g:2418:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) )
+            // InternalFSM.g:2464:1: ( ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) )
+            // InternalFSM.g:2465:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) )
             {
-            // InternalFSM.g:2418:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) )
-            // InternalFSM.g:2419:1: ( rule__ModelComponent__ComponentNameAssignment_2 )
+            // InternalFSM.g:2465:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) )
+            // InternalFSM.g:2466:1: ( rule__ModelComponent__ComponentNameAssignment_2 )
             {
              before(grammarAccess.getModelComponentAccess().getComponentNameAssignment_2()); 
-            // InternalFSM.g:2420:1: ( rule__ModelComponent__ComponentNameAssignment_2 )
-            // InternalFSM.g:2420:2: rule__ModelComponent__ComponentNameAssignment_2
+            // InternalFSM.g:2467:1: ( rule__ModelComponent__ComponentNameAssignment_2 )
+            // InternalFSM.g:2467:2: rule__ModelComponent__ComponentNameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__ComponentNameAssignment_2();
@@ -7535,14 +7691,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__3"
-    // InternalFSM.g:2430:1: rule__ModelComponent__Group__3 : rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 ;
+    // InternalFSM.g:2477:1: rule__ModelComponent__Group__3 : rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 ;
     public final void rule__ModelComponent__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2434:1: ( rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 )
-            // InternalFSM.g:2435:2: rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4
+            // InternalFSM.g:2481:1: ( rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 )
+            // InternalFSM.g:2482:2: rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4
             {
             pushFollow(FOLLOW_6);
             rule__ModelComponent__Group__3__Impl();
@@ -7573,29 +7729,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__3__Impl"
-    // InternalFSM.g:2442:1: rule__ModelComponent__Group__3__Impl : ( ( rule__ModelComponent__Group_3__0 )? ) ;
+    // InternalFSM.g:2489:1: rule__ModelComponent__Group__3__Impl : ( ( rule__ModelComponent__Group_3__0 )? ) ;
     public final void rule__ModelComponent__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2446:1: ( ( ( rule__ModelComponent__Group_3__0 )? ) )
-            // InternalFSM.g:2447:1: ( ( rule__ModelComponent__Group_3__0 )? )
+            // InternalFSM.g:2493:1: ( ( ( rule__ModelComponent__Group_3__0 )? ) )
+            // InternalFSM.g:2494:1: ( ( rule__ModelComponent__Group_3__0 )? )
             {
-            // InternalFSM.g:2447:1: ( ( rule__ModelComponent__Group_3__0 )? )
-            // InternalFSM.g:2448:1: ( rule__ModelComponent__Group_3__0 )?
+            // InternalFSM.g:2494:1: ( ( rule__ModelComponent__Group_3__0 )? )
+            // InternalFSM.g:2495:1: ( rule__ModelComponent__Group_3__0 )?
             {
              before(grammarAccess.getModelComponentAccess().getGroup_3()); 
-            // InternalFSM.g:2449:1: ( rule__ModelComponent__Group_3__0 )?
-            int alt30=2;
-            int LA30_0 = input.LA(1);
+            // InternalFSM.g:2496:1: ( rule__ModelComponent__Group_3__0 )?
+            int alt31=2;
+            int LA31_0 = input.LA(1);
 
-            if ( (LA30_0==28) ) {
-                alt30=1;
+            if ( (LA31_0==28) ) {
+                alt31=1;
             }
-            switch (alt30) {
+            switch (alt31) {
                 case 1 :
-                    // InternalFSM.g:2449:2: rule__ModelComponent__Group_3__0
+                    // InternalFSM.g:2496:2: rule__ModelComponent__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ModelComponent__Group_3__0();
@@ -7631,14 +7787,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__4"
-    // InternalFSM.g:2459:1: rule__ModelComponent__Group__4 : rule__ModelComponent__Group__4__Impl ;
+    // InternalFSM.g:2506:1: rule__ModelComponent__Group__4 : rule__ModelComponent__Group__4__Impl ;
     public final void rule__ModelComponent__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2463:1: ( rule__ModelComponent__Group__4__Impl )
-            // InternalFSM.g:2464:2: rule__ModelComponent__Group__4__Impl
+            // InternalFSM.g:2510:1: ( rule__ModelComponent__Group__4__Impl )
+            // InternalFSM.g:2511:2: rule__ModelComponent__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__Group__4__Impl();
@@ -7664,21 +7820,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group__4__Impl"
-    // InternalFSM.g:2470:1: rule__ModelComponent__Group__4__Impl : ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) ;
+    // InternalFSM.g:2517:1: rule__ModelComponent__Group__4__Impl : ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) ;
     public final void rule__ModelComponent__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2474:1: ( ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) )
-            // InternalFSM.g:2475:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) )
+            // InternalFSM.g:2521:1: ( ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) )
+            // InternalFSM.g:2522:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) )
             {
-            // InternalFSM.g:2475:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) )
-            // InternalFSM.g:2476:1: ( rule__ModelComponent__StateMachineAssignment_4 )
+            // InternalFSM.g:2522:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) )
+            // InternalFSM.g:2523:1: ( rule__ModelComponent__StateMachineAssignment_4 )
             {
              before(grammarAccess.getModelComponentAccess().getStateMachineAssignment_4()); 
-            // InternalFSM.g:2477:1: ( rule__ModelComponent__StateMachineAssignment_4 )
-            // InternalFSM.g:2477:2: rule__ModelComponent__StateMachineAssignment_4
+            // InternalFSM.g:2524:1: ( rule__ModelComponent__StateMachineAssignment_4 )
+            // InternalFSM.g:2524:2: rule__ModelComponent__StateMachineAssignment_4
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__StateMachineAssignment_4();
@@ -7711,14 +7867,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group_3__0"
-    // InternalFSM.g:2497:1: rule__ModelComponent__Group_3__0 : rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 ;
+    // InternalFSM.g:2544:1: rule__ModelComponent__Group_3__0 : rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 ;
     public final void rule__ModelComponent__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2501:1: ( rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 )
-            // InternalFSM.g:2502:2: rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1
+            // InternalFSM.g:2548:1: ( rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 )
+            // InternalFSM.g:2549:2: rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1
             {
             pushFollow(FOLLOW_5);
             rule__ModelComponent__Group_3__0__Impl();
@@ -7749,17 +7905,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group_3__0__Impl"
-    // InternalFSM.g:2509:1: rule__ModelComponent__Group_3__0__Impl : ( 'extends' ) ;
+    // InternalFSM.g:2556:1: rule__ModelComponent__Group_3__0__Impl : ( 'extends' ) ;
     public final void rule__ModelComponent__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2513:1: ( ( 'extends' ) )
-            // InternalFSM.g:2514:1: ( 'extends' )
+            // InternalFSM.g:2560:1: ( ( 'extends' ) )
+            // InternalFSM.g:2561:1: ( 'extends' )
             {
-            // InternalFSM.g:2514:1: ( 'extends' )
-            // InternalFSM.g:2515:1: 'extends'
+            // InternalFSM.g:2561:1: ( 'extends' )
+            // InternalFSM.g:2562:1: 'extends'
             {
              before(grammarAccess.getModelComponentAccess().getExtendsKeyword_3_0()); 
             match(input,28,FOLLOW_2); 
@@ -7786,14 +7942,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group_3__1"
-    // InternalFSM.g:2528:1: rule__ModelComponent__Group_3__1 : rule__ModelComponent__Group_3__1__Impl ;
+    // InternalFSM.g:2575:1: rule__ModelComponent__Group_3__1 : rule__ModelComponent__Group_3__1__Impl ;
     public final void rule__ModelComponent__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2532:1: ( rule__ModelComponent__Group_3__1__Impl )
-            // InternalFSM.g:2533:2: rule__ModelComponent__Group_3__1__Impl
+            // InternalFSM.g:2579:1: ( rule__ModelComponent__Group_3__1__Impl )
+            // InternalFSM.g:2580:2: rule__ModelComponent__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__Group_3__1__Impl();
@@ -7819,21 +7975,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__Group_3__1__Impl"
-    // InternalFSM.g:2539:1: rule__ModelComponent__Group_3__1__Impl : ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) ;
+    // InternalFSM.g:2586:1: rule__ModelComponent__Group_3__1__Impl : ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) ;
     public final void rule__ModelComponent__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2543:1: ( ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) )
-            // InternalFSM.g:2544:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) )
+            // InternalFSM.g:2590:1: ( ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) )
+            // InternalFSM.g:2591:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) )
             {
-            // InternalFSM.g:2544:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) )
-            // InternalFSM.g:2545:1: ( rule__ModelComponent__BaseAssignment_3_1 )
+            // InternalFSM.g:2591:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) )
+            // InternalFSM.g:2592:1: ( rule__ModelComponent__BaseAssignment_3_1 )
             {
              before(grammarAccess.getModelComponentAccess().getBaseAssignment_3_1()); 
-            // InternalFSM.g:2546:1: ( rule__ModelComponent__BaseAssignment_3_1 )
-            // InternalFSM.g:2546:2: rule__ModelComponent__BaseAssignment_3_1
+            // InternalFSM.g:2593:1: ( rule__ModelComponent__BaseAssignment_3_1 )
+            // InternalFSM.g:2593:2: rule__ModelComponent__BaseAssignment_3_1
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__BaseAssignment_3_1();
@@ -7866,14 +8022,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__0"
-    // InternalFSM.g:2560:1: rule__StateGraph__Group__0 : rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ;
+    // InternalFSM.g:2607:1: rule__StateGraph__Group__0 : rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ;
     public final void rule__StateGraph__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2564:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 )
-            // InternalFSM.g:2565:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1
+            // InternalFSM.g:2611:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 )
+            // InternalFSM.g:2612:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1
             {
             pushFollow(FOLLOW_7);
             rule__StateGraph__Group__0__Impl();
@@ -7904,21 +8060,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__0__Impl"
-    // InternalFSM.g:2572:1: rule__StateGraph__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:2619:1: rule__StateGraph__Group__0__Impl : ( () ) ;
     public final void rule__StateGraph__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2576:1: ( ( () ) )
-            // InternalFSM.g:2577:1: ( () )
+            // InternalFSM.g:2623:1: ( ( () ) )
+            // InternalFSM.g:2624:1: ( () )
             {
-            // InternalFSM.g:2577:1: ( () )
-            // InternalFSM.g:2578:1: ()
+            // InternalFSM.g:2624:1: ( () )
+            // InternalFSM.g:2625:1: ()
             {
              before(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); 
-            // InternalFSM.g:2579:1: ()
-            // InternalFSM.g:2581:1: 
+            // InternalFSM.g:2626:1: ()
+            // InternalFSM.g:2628:1: 
             {
             }
 
@@ -7941,14 +8097,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__1"
-    // InternalFSM.g:2591:1: rule__StateGraph__Group__1 : rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ;
+    // InternalFSM.g:2638:1: rule__StateGraph__Group__1 : rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ;
     public final void rule__StateGraph__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2595:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 )
-            // InternalFSM.g:2596:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2
+            // InternalFSM.g:2642:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 )
+            // InternalFSM.g:2643:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__StateGraph__Group__1__Impl();
@@ -7979,17 +8135,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__1__Impl"
-    // InternalFSM.g:2603:1: rule__StateGraph__Group__1__Impl : ( '{' ) ;
+    // InternalFSM.g:2650:1: rule__StateGraph__Group__1__Impl : ( '{' ) ;
     public final void rule__StateGraph__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2607:1: ( ( '{' ) )
-            // InternalFSM.g:2608:1: ( '{' )
+            // InternalFSM.g:2654:1: ( ( '{' ) )
+            // InternalFSM.g:2655:1: ( '{' )
             {
-            // InternalFSM.g:2608:1: ( '{' )
-            // InternalFSM.g:2609:1: '{'
+            // InternalFSM.g:2655:1: ( '{' )
+            // InternalFSM.g:2656:1: '{'
             {
              before(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); 
             match(input,29,FOLLOW_2); 
@@ -8016,14 +8172,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__2"
-    // InternalFSM.g:2622:1: rule__StateGraph__Group__2 : rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ;
+    // InternalFSM.g:2669:1: rule__StateGraph__Group__2 : rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ;
     public final void rule__StateGraph__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2626:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 )
-            // InternalFSM.g:2627:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3
+            // InternalFSM.g:2673:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 )
+            // InternalFSM.g:2674:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__StateGraph__Group__2__Impl();
@@ -8054,33 +8210,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__2__Impl"
-    // InternalFSM.g:2634:1: rule__StateGraph__Group__2__Impl : ( ( rule__StateGraph__Alternatives_2 )* ) ;
+    // InternalFSM.g:2681:1: rule__StateGraph__Group__2__Impl : ( ( rule__StateGraph__Alternatives_2 )* ) ;
     public final void rule__StateGraph__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2638:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) )
-            // InternalFSM.g:2639:1: ( ( rule__StateGraph__Alternatives_2 )* )
+            // InternalFSM.g:2685:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) )
+            // InternalFSM.g:2686:1: ( ( rule__StateGraph__Alternatives_2 )* )
             {
-            // InternalFSM.g:2639:1: ( ( rule__StateGraph__Alternatives_2 )* )
-            // InternalFSM.g:2640:1: ( rule__StateGraph__Alternatives_2 )*
+            // InternalFSM.g:2686:1: ( ( rule__StateGraph__Alternatives_2 )* )
+            // InternalFSM.g:2687:1: ( rule__StateGraph__Alternatives_2 )*
             {
              before(grammarAccess.getStateGraphAccess().getAlternatives_2()); 
-            // InternalFSM.g:2641:1: ( rule__StateGraph__Alternatives_2 )*
-            loop31:
+            // InternalFSM.g:2688:1: ( rule__StateGraph__Alternatives_2 )*
+            loop32:
             do {
-                int alt31=2;
-                int LA31_0 = input.LA(1);
+                int alt32=2;
+                int LA32_0 = input.LA(1);
 
-                if ( (LA31_0==32||(LA31_0>=37 && LA31_0<=42)||LA31_0==51||LA31_0==70) ) {
-                    alt31=1;
+                if ( (LA32_0==32||(LA32_0>=37 && LA32_0<=42)||LA32_0==51||LA32_0==70) ) {
+                    alt32=1;
                 }
 
 
-                switch (alt31) {
+                switch (alt32) {
             	case 1 :
-            	    // InternalFSM.g:2641:2: rule__StateGraph__Alternatives_2
+            	    // InternalFSM.g:2688:2: rule__StateGraph__Alternatives_2
             	    {
             	    pushFollow(FOLLOW_9);
             	    rule__StateGraph__Alternatives_2();
@@ -8092,7 +8248,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop31;
+            	    break loop32;
                 }
             } while (true);
 
@@ -8119,14 +8275,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__3"
-    // InternalFSM.g:2651:1: rule__StateGraph__Group__3 : rule__StateGraph__Group__3__Impl ;
+    // InternalFSM.g:2698:1: rule__StateGraph__Group__3 : rule__StateGraph__Group__3__Impl ;
     public final void rule__StateGraph__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2655:1: ( rule__StateGraph__Group__3__Impl )
-            // InternalFSM.g:2656:2: rule__StateGraph__Group__3__Impl
+            // InternalFSM.g:2702:1: ( rule__StateGraph__Group__3__Impl )
+            // InternalFSM.g:2703:2: rule__StateGraph__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateGraph__Group__3__Impl();
@@ -8152,17 +8308,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__3__Impl"
-    // InternalFSM.g:2662:1: rule__StateGraph__Group__3__Impl : ( '}' ) ;
+    // InternalFSM.g:2709:1: rule__StateGraph__Group__3__Impl : ( '}' ) ;
     public final void rule__StateGraph__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2666:1: ( ( '}' ) )
-            // InternalFSM.g:2667:1: ( '}' )
+            // InternalFSM.g:2713:1: ( ( '}' ) )
+            // InternalFSM.g:2714:1: ( '}' )
             {
-            // InternalFSM.g:2667:1: ( '}' )
-            // InternalFSM.g:2668:1: '}'
+            // InternalFSM.g:2714:1: ( '}' )
+            // InternalFSM.g:2715:1: '}'
             {
              before(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); 
             match(input,30,FOLLOW_2); 
@@ -8189,14 +8345,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__0"
-    // InternalFSM.g:2689:1: rule__StateMachine__Group__0 : rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ;
+    // InternalFSM.g:2736:1: rule__StateMachine__Group__0 : rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ;
     public final void rule__StateMachine__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2693:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 )
-            // InternalFSM.g:2694:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1
+            // InternalFSM.g:2740:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 )
+            // InternalFSM.g:2741:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1
             {
             pushFollow(FOLLOW_6);
             rule__StateMachine__Group__0__Impl();
@@ -8227,21 +8383,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__0__Impl"
-    // InternalFSM.g:2701:1: rule__StateMachine__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:2748:1: rule__StateMachine__Group__0__Impl : ( () ) ;
     public final void rule__StateMachine__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2705:1: ( ( () ) )
-            // InternalFSM.g:2706:1: ( () )
+            // InternalFSM.g:2752:1: ( ( () ) )
+            // InternalFSM.g:2753:1: ( () )
             {
-            // InternalFSM.g:2706:1: ( () )
-            // InternalFSM.g:2707:1: ()
+            // InternalFSM.g:2753:1: ( () )
+            // InternalFSM.g:2754:1: ()
             {
              before(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); 
-            // InternalFSM.g:2708:1: ()
-            // InternalFSM.g:2710:1: 
+            // InternalFSM.g:2755:1: ()
+            // InternalFSM.g:2757:1: 
             {
             }
 
@@ -8264,14 +8420,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__1"
-    // InternalFSM.g:2720:1: rule__StateMachine__Group__1 : rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ;
+    // InternalFSM.g:2767:1: rule__StateMachine__Group__1 : rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ;
     public final void rule__StateMachine__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2724:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 )
-            // InternalFSM.g:2725:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2
+            // InternalFSM.g:2771:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 )
+            // InternalFSM.g:2772:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2
             {
             pushFollow(FOLLOW_7);
             rule__StateMachine__Group__1__Impl();
@@ -8302,17 +8458,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__1__Impl"
-    // InternalFSM.g:2732:1: rule__StateMachine__Group__1__Impl : ( 'StateMachine' ) ;
+    // InternalFSM.g:2779:1: rule__StateMachine__Group__1__Impl : ( 'StateMachine' ) ;
     public final void rule__StateMachine__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2736:1: ( ( 'StateMachine' ) )
-            // InternalFSM.g:2737:1: ( 'StateMachine' )
+            // InternalFSM.g:2783:1: ( ( 'StateMachine' ) )
+            // InternalFSM.g:2784:1: ( 'StateMachine' )
             {
-            // InternalFSM.g:2737:1: ( 'StateMachine' )
-            // InternalFSM.g:2738:1: 'StateMachine'
+            // InternalFSM.g:2784:1: ( 'StateMachine' )
+            // InternalFSM.g:2785:1: 'StateMachine'
             {
              before(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); 
             match(input,31,FOLLOW_2); 
@@ -8339,14 +8495,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__2"
-    // InternalFSM.g:2751:1: rule__StateMachine__Group__2 : rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ;
+    // InternalFSM.g:2798:1: rule__StateMachine__Group__2 : rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ;
     public final void rule__StateMachine__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2755:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 )
-            // InternalFSM.g:2756:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3
+            // InternalFSM.g:2802:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 )
+            // InternalFSM.g:2803:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__StateMachine__Group__2__Impl();
@@ -8377,17 +8533,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__2__Impl"
-    // InternalFSM.g:2763:1: rule__StateMachine__Group__2__Impl : ( '{' ) ;
+    // InternalFSM.g:2810:1: rule__StateMachine__Group__2__Impl : ( '{' ) ;
     public final void rule__StateMachine__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2767:1: ( ( '{' ) )
-            // InternalFSM.g:2768:1: ( '{' )
+            // InternalFSM.g:2814:1: ( ( '{' ) )
+            // InternalFSM.g:2815:1: ( '{' )
             {
-            // InternalFSM.g:2768:1: ( '{' )
-            // InternalFSM.g:2769:1: '{'
+            // InternalFSM.g:2815:1: ( '{' )
+            // InternalFSM.g:2816:1: '{'
             {
              before(grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2()); 
             match(input,29,FOLLOW_2); 
@@ -8414,14 +8570,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__3"
-    // InternalFSM.g:2782:1: rule__StateMachine__Group__3 : rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ;
+    // InternalFSM.g:2829:1: rule__StateMachine__Group__3 : rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ;
     public final void rule__StateMachine__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2786:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 )
-            // InternalFSM.g:2787:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4
+            // InternalFSM.g:2833:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 )
+            // InternalFSM.g:2834:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4
             {
             pushFollow(FOLLOW_8);
             rule__StateMachine__Group__3__Impl();
@@ -8452,33 +8608,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__3__Impl"
-    // InternalFSM.g:2794:1: rule__StateMachine__Group__3__Impl : ( ( rule__StateMachine__Alternatives_3 )* ) ;
+    // InternalFSM.g:2841:1: rule__StateMachine__Group__3__Impl : ( ( rule__StateMachine__Alternatives_3 )* ) ;
     public final void rule__StateMachine__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2798:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) )
-            // InternalFSM.g:2799:1: ( ( rule__StateMachine__Alternatives_3 )* )
+            // InternalFSM.g:2845:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) )
+            // InternalFSM.g:2846:1: ( ( rule__StateMachine__Alternatives_3 )* )
             {
-            // InternalFSM.g:2799:1: ( ( rule__StateMachine__Alternatives_3 )* )
-            // InternalFSM.g:2800:1: ( rule__StateMachine__Alternatives_3 )*
+            // InternalFSM.g:2846:1: ( ( rule__StateMachine__Alternatives_3 )* )
+            // InternalFSM.g:2847:1: ( rule__StateMachine__Alternatives_3 )*
             {
              before(grammarAccess.getStateMachineAccess().getAlternatives_3()); 
-            // InternalFSM.g:2801:1: ( rule__StateMachine__Alternatives_3 )*
-            loop32:
+            // InternalFSM.g:2848:1: ( rule__StateMachine__Alternatives_3 )*
+            loop33:
             do {
-                int alt32=2;
-                int LA32_0 = input.LA(1);
+                int alt33=2;
+                int LA33_0 = input.LA(1);
 
-                if ( (LA32_0==32||(LA32_0>=37 && LA32_0<=42)||LA32_0==51||LA32_0==70) ) {
-                    alt32=1;
+                if ( (LA33_0==32||(LA33_0>=37 && LA33_0<=42)||LA33_0==51||LA33_0==70) ) {
+                    alt33=1;
                 }
 
 
-                switch (alt32) {
+                switch (alt33) {
             	case 1 :
-            	    // InternalFSM.g:2801:2: rule__StateMachine__Alternatives_3
+            	    // InternalFSM.g:2848:2: rule__StateMachine__Alternatives_3
             	    {
             	    pushFollow(FOLLOW_9);
             	    rule__StateMachine__Alternatives_3();
@@ -8490,7 +8646,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop32;
+            	    break loop33;
                 }
             } while (true);
 
@@ -8517,14 +8673,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__4"
-    // InternalFSM.g:2811:1: rule__StateMachine__Group__4 : rule__StateMachine__Group__4__Impl ;
+    // InternalFSM.g:2858:1: rule__StateMachine__Group__4 : rule__StateMachine__Group__4__Impl ;
     public final void rule__StateMachine__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2815:1: ( rule__StateMachine__Group__4__Impl )
-            // InternalFSM.g:2816:2: rule__StateMachine__Group__4__Impl
+            // InternalFSM.g:2862:1: ( rule__StateMachine__Group__4__Impl )
+            // InternalFSM.g:2863:2: rule__StateMachine__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateMachine__Group__4__Impl();
@@ -8550,17 +8706,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__4__Impl"
-    // InternalFSM.g:2822:1: rule__StateMachine__Group__4__Impl : ( '}' ) ;
+    // InternalFSM.g:2869:1: rule__StateMachine__Group__4__Impl : ( '}' ) ;
     public final void rule__StateMachine__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2826:1: ( ( '}' ) )
-            // InternalFSM.g:2827:1: ( '}' )
+            // InternalFSM.g:2873:1: ( ( '}' ) )
+            // InternalFSM.g:2874:1: ( '}' )
             {
-            // InternalFSM.g:2827:1: ( '}' )
-            // InternalFSM.g:2828:1: '}'
+            // InternalFSM.g:2874:1: ( '}' )
+            // InternalFSM.g:2875:1: '}'
             {
              before(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); 
             match(input,30,FOLLOW_2); 
@@ -8587,14 +8743,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__0"
-    // InternalFSM.g:2851:1: rule__SimpleState__Group__0 : rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ;
+    // InternalFSM.g:2898:1: rule__SimpleState__Group__0 : rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ;
     public final void rule__SimpleState__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2855:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 )
-            // InternalFSM.g:2856:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1
+            // InternalFSM.g:2902:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 )
+            // InternalFSM.g:2903:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__SimpleState__Group__0__Impl();
@@ -8625,17 +8781,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__0__Impl"
-    // InternalFSM.g:2863:1: rule__SimpleState__Group__0__Impl : ( 'State' ) ;
+    // InternalFSM.g:2910:1: rule__SimpleState__Group__0__Impl : ( 'State' ) ;
     public final void rule__SimpleState__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2867:1: ( ( 'State' ) )
-            // InternalFSM.g:2868:1: ( 'State' )
+            // InternalFSM.g:2914:1: ( ( 'State' ) )
+            // InternalFSM.g:2915:1: ( 'State' )
             {
-            // InternalFSM.g:2868:1: ( 'State' )
-            // InternalFSM.g:2869:1: 'State'
+            // InternalFSM.g:2915:1: ( 'State' )
+            // InternalFSM.g:2916:1: 'State'
             {
              before(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); 
             match(input,32,FOLLOW_2); 
@@ -8662,14 +8818,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__1"
-    // InternalFSM.g:2882:1: rule__SimpleState__Group__1 : rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ;
+    // InternalFSM.g:2929:1: rule__SimpleState__Group__1 : rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ;
     public final void rule__SimpleState__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2886:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 )
-            // InternalFSM.g:2887:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2
+            // InternalFSM.g:2933:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 )
+            // InternalFSM.g:2934:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2
             {
             pushFollow(FOLLOW_10);
             rule__SimpleState__Group__1__Impl();
@@ -8700,21 +8856,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__1__Impl"
-    // InternalFSM.g:2894:1: rule__SimpleState__Group__1__Impl : ( ( rule__SimpleState__NameAssignment_1 ) ) ;
+    // InternalFSM.g:2941:1: rule__SimpleState__Group__1__Impl : ( ( rule__SimpleState__NameAssignment_1 ) ) ;
     public final void rule__SimpleState__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2898:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) )
-            // InternalFSM.g:2899:1: ( ( rule__SimpleState__NameAssignment_1 ) )
+            // InternalFSM.g:2945:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) )
+            // InternalFSM.g:2946:1: ( ( rule__SimpleState__NameAssignment_1 ) )
             {
-            // InternalFSM.g:2899:1: ( ( rule__SimpleState__NameAssignment_1 ) )
-            // InternalFSM.g:2900:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalFSM.g:2946:1: ( ( rule__SimpleState__NameAssignment_1 ) )
+            // InternalFSM.g:2947:1: ( rule__SimpleState__NameAssignment_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); 
-            // InternalFSM.g:2901:1: ( rule__SimpleState__NameAssignment_1 )
-            // InternalFSM.g:2901:2: rule__SimpleState__NameAssignment_1
+            // InternalFSM.g:2948:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalFSM.g:2948:2: rule__SimpleState__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__NameAssignment_1();
@@ -8747,14 +8903,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__2"
-    // InternalFSM.g:2911:1: rule__SimpleState__Group__2 : rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ;
+    // InternalFSM.g:2958:1: rule__SimpleState__Group__2 : rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ;
     public final void rule__SimpleState__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2915:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 )
-            // InternalFSM.g:2916:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3
+            // InternalFSM.g:2962:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 )
+            // InternalFSM.g:2963:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3
             {
             pushFollow(FOLLOW_10);
             rule__SimpleState__Group__2__Impl();
@@ -8785,29 +8941,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__2__Impl"
-    // InternalFSM.g:2923:1: rule__SimpleState__Group__2__Impl : ( ( rule__SimpleState__DocuAssignment_2 )? ) ;
+    // InternalFSM.g:2970:1: rule__SimpleState__Group__2__Impl : ( ( rule__SimpleState__DocuAssignment_2 )? ) ;
     public final void rule__SimpleState__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2927:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) )
-            // InternalFSM.g:2928:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
+            // InternalFSM.g:2974:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) )
+            // InternalFSM.g:2975:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
             {
-            // InternalFSM.g:2928:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
-            // InternalFSM.g:2929:1: ( rule__SimpleState__DocuAssignment_2 )?
+            // InternalFSM.g:2975:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
+            // InternalFSM.g:2976:1: ( rule__SimpleState__DocuAssignment_2 )?
             {
              before(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); 
-            // InternalFSM.g:2930:1: ( rule__SimpleState__DocuAssignment_2 )?
-            int alt33=2;
-            int LA33_0 = input.LA(1);
+            // InternalFSM.g:2977:1: ( rule__SimpleState__DocuAssignment_2 )?
+            int alt34=2;
+            int LA34_0 = input.LA(1);
 
-            if ( (LA33_0==66) ) {
-                alt33=1;
+            if ( (LA34_0==66) ) {
+                alt34=1;
             }
-            switch (alt33) {
+            switch (alt34) {
                 case 1 :
-                    // InternalFSM.g:2930:2: rule__SimpleState__DocuAssignment_2
+                    // InternalFSM.g:2977:2: rule__SimpleState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__DocuAssignment_2();
@@ -8843,14 +8999,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__3"
-    // InternalFSM.g:2940:1: rule__SimpleState__Group__3 : rule__SimpleState__Group__3__Impl ;
+    // InternalFSM.g:2987:1: rule__SimpleState__Group__3 : rule__SimpleState__Group__3__Impl ;
     public final void rule__SimpleState__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2944:1: ( rule__SimpleState__Group__3__Impl )
-            // InternalFSM.g:2945:2: rule__SimpleState__Group__3__Impl
+            // InternalFSM.g:2991:1: ( rule__SimpleState__Group__3__Impl )
+            // InternalFSM.g:2992:2: rule__SimpleState__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group__3__Impl();
@@ -8876,29 +9032,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__3__Impl"
-    // InternalFSM.g:2951:1: rule__SimpleState__Group__3__Impl : ( ( rule__SimpleState__Group_3__0 )? ) ;
+    // InternalFSM.g:2998:1: rule__SimpleState__Group__3__Impl : ( ( rule__SimpleState__Group_3__0 )? ) ;
     public final void rule__SimpleState__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2955:1: ( ( ( rule__SimpleState__Group_3__0 )? ) )
-            // InternalFSM.g:2956:1: ( ( rule__SimpleState__Group_3__0 )? )
+            // InternalFSM.g:3002:1: ( ( ( rule__SimpleState__Group_3__0 )? ) )
+            // InternalFSM.g:3003:1: ( ( rule__SimpleState__Group_3__0 )? )
             {
-            // InternalFSM.g:2956:1: ( ( rule__SimpleState__Group_3__0 )? )
-            // InternalFSM.g:2957:1: ( rule__SimpleState__Group_3__0 )?
+            // InternalFSM.g:3003:1: ( ( rule__SimpleState__Group_3__0 )? )
+            // InternalFSM.g:3004:1: ( rule__SimpleState__Group_3__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3()); 
-            // InternalFSM.g:2958:1: ( rule__SimpleState__Group_3__0 )?
-            int alt34=2;
-            int LA34_0 = input.LA(1);
+            // InternalFSM.g:3005:1: ( rule__SimpleState__Group_3__0 )?
+            int alt35=2;
+            int LA35_0 = input.LA(1);
 
-            if ( (LA34_0==29) ) {
-                alt34=1;
+            if ( (LA35_0==29) ) {
+                alt35=1;
             }
-            switch (alt34) {
+            switch (alt35) {
                 case 1 :
-                    // InternalFSM.g:2958:2: rule__SimpleState__Group_3__0
+                    // InternalFSM.g:3005:2: rule__SimpleState__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3__0();
@@ -8934,14 +9090,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__0"
-    // InternalFSM.g:2976:1: rule__SimpleState__Group_3__0 : rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ;
+    // InternalFSM.g:3023:1: rule__SimpleState__Group_3__0 : rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ;
     public final void rule__SimpleState__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2980:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 )
-            // InternalFSM.g:2981:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1
+            // InternalFSM.g:3027:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 )
+            // InternalFSM.g:3028:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1
             {
             pushFollow(FOLLOW_11);
             rule__SimpleState__Group_3__0__Impl();
@@ -8972,17 +9128,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__0__Impl"
-    // InternalFSM.g:2988:1: rule__SimpleState__Group_3__0__Impl : ( '{' ) ;
+    // InternalFSM.g:3035:1: rule__SimpleState__Group_3__0__Impl : ( '{' ) ;
     public final void rule__SimpleState__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:2992:1: ( ( '{' ) )
-            // InternalFSM.g:2993:1: ( '{' )
+            // InternalFSM.g:3039:1: ( ( '{' ) )
+            // InternalFSM.g:3040:1: ( '{' )
             {
-            // InternalFSM.g:2993:1: ( '{' )
-            // InternalFSM.g:2994:1: '{'
+            // InternalFSM.g:3040:1: ( '{' )
+            // InternalFSM.g:3041:1: '{'
             {
              before(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); 
             match(input,29,FOLLOW_2); 
@@ -9009,14 +9165,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__1"
-    // InternalFSM.g:3007:1: rule__SimpleState__Group_3__1 : rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ;
+    // InternalFSM.g:3054:1: rule__SimpleState__Group_3__1 : rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ;
     public final void rule__SimpleState__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3011:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 )
-            // InternalFSM.g:3012:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2
+            // InternalFSM.g:3058:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 )
+            // InternalFSM.g:3059:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2
             {
             pushFollow(FOLLOW_11);
             rule__SimpleState__Group_3__1__Impl();
@@ -9047,29 +9203,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__1__Impl"
-    // InternalFSM.g:3019:1: rule__SimpleState__Group_3__1__Impl : ( ( rule__SimpleState__Group_3_1__0 )? ) ;
+    // InternalFSM.g:3066:1: rule__SimpleState__Group_3__1__Impl : ( ( rule__SimpleState__Group_3_1__0 )? ) ;
     public final void rule__SimpleState__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3023:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) )
-            // InternalFSM.g:3024:1: ( ( rule__SimpleState__Group_3_1__0 )? )
+            // InternalFSM.g:3070:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) )
+            // InternalFSM.g:3071:1: ( ( rule__SimpleState__Group_3_1__0 )? )
             {
-            // InternalFSM.g:3024:1: ( ( rule__SimpleState__Group_3_1__0 )? )
-            // InternalFSM.g:3025:1: ( rule__SimpleState__Group_3_1__0 )?
+            // InternalFSM.g:3071:1: ( ( rule__SimpleState__Group_3_1__0 )? )
+            // InternalFSM.g:3072:1: ( rule__SimpleState__Group_3_1__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_1()); 
-            // InternalFSM.g:3026:1: ( rule__SimpleState__Group_3_1__0 )?
-            int alt35=2;
-            int LA35_0 = input.LA(1);
+            // InternalFSM.g:3073:1: ( rule__SimpleState__Group_3_1__0 )?
+            int alt36=2;
+            int LA36_0 = input.LA(1);
 
-            if ( (LA35_0==33) ) {
-                alt35=1;
+            if ( (LA36_0==33) ) {
+                alt36=1;
             }
-            switch (alt35) {
+            switch (alt36) {
                 case 1 :
-                    // InternalFSM.g:3026:2: rule__SimpleState__Group_3_1__0
+                    // InternalFSM.g:3073:2: rule__SimpleState__Group_3_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_1__0();
@@ -9105,14 +9261,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__2"
-    // InternalFSM.g:3036:1: rule__SimpleState__Group_3__2 : rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ;
+    // InternalFSM.g:3083:1: rule__SimpleState__Group_3__2 : rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ;
     public final void rule__SimpleState__Group_3__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3040:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 )
-            // InternalFSM.g:3041:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3
+            // InternalFSM.g:3087:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 )
+            // InternalFSM.g:3088:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3
             {
             pushFollow(FOLLOW_11);
             rule__SimpleState__Group_3__2__Impl();
@@ -9143,29 +9299,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__2__Impl"
-    // InternalFSM.g:3048:1: rule__SimpleState__Group_3__2__Impl : ( ( rule__SimpleState__Group_3_2__0 )? ) ;
+    // InternalFSM.g:3095:1: rule__SimpleState__Group_3__2__Impl : ( ( rule__SimpleState__Group_3_2__0 )? ) ;
     public final void rule__SimpleState__Group_3__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3052:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) )
-            // InternalFSM.g:3053:1: ( ( rule__SimpleState__Group_3_2__0 )? )
+            // InternalFSM.g:3099:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) )
+            // InternalFSM.g:3100:1: ( ( rule__SimpleState__Group_3_2__0 )? )
             {
-            // InternalFSM.g:3053:1: ( ( rule__SimpleState__Group_3_2__0 )? )
-            // InternalFSM.g:3054:1: ( rule__SimpleState__Group_3_2__0 )?
+            // InternalFSM.g:3100:1: ( ( rule__SimpleState__Group_3_2__0 )? )
+            // InternalFSM.g:3101:1: ( rule__SimpleState__Group_3_2__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_2()); 
-            // InternalFSM.g:3055:1: ( rule__SimpleState__Group_3_2__0 )?
-            int alt36=2;
-            int LA36_0 = input.LA(1);
+            // InternalFSM.g:3102:1: ( rule__SimpleState__Group_3_2__0 )?
+            int alt37=2;
+            int LA37_0 = input.LA(1);
 
-            if ( (LA36_0==34) ) {
-                alt36=1;
+            if ( (LA37_0==34) ) {
+                alt37=1;
             }
-            switch (alt36) {
+            switch (alt37) {
                 case 1 :
-                    // InternalFSM.g:3055:2: rule__SimpleState__Group_3_2__0
+                    // InternalFSM.g:3102:2: rule__SimpleState__Group_3_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_2__0();
@@ -9201,14 +9357,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__3"
-    // InternalFSM.g:3065:1: rule__SimpleState__Group_3__3 : rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ;
+    // InternalFSM.g:3112:1: rule__SimpleState__Group_3__3 : rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ;
     public final void rule__SimpleState__Group_3__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3069:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 )
-            // InternalFSM.g:3070:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4
+            // InternalFSM.g:3116:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 )
+            // InternalFSM.g:3117:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4
             {
             pushFollow(FOLLOW_11);
             rule__SimpleState__Group_3__3__Impl();
@@ -9239,29 +9395,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__3__Impl"
-    // InternalFSM.g:3077:1: rule__SimpleState__Group_3__3__Impl : ( ( rule__SimpleState__Group_3_3__0 )? ) ;
+    // InternalFSM.g:3124:1: rule__SimpleState__Group_3__3__Impl : ( ( rule__SimpleState__Group_3_3__0 )? ) ;
     public final void rule__SimpleState__Group_3__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3081:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) )
-            // InternalFSM.g:3082:1: ( ( rule__SimpleState__Group_3_3__0 )? )
+            // InternalFSM.g:3128:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) )
+            // InternalFSM.g:3129:1: ( ( rule__SimpleState__Group_3_3__0 )? )
             {
-            // InternalFSM.g:3082:1: ( ( rule__SimpleState__Group_3_3__0 )? )
-            // InternalFSM.g:3083:1: ( rule__SimpleState__Group_3_3__0 )?
+            // InternalFSM.g:3129:1: ( ( rule__SimpleState__Group_3_3__0 )? )
+            // InternalFSM.g:3130:1: ( rule__SimpleState__Group_3_3__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_3()); 
-            // InternalFSM.g:3084:1: ( rule__SimpleState__Group_3_3__0 )?
-            int alt37=2;
-            int LA37_0 = input.LA(1);
+            // InternalFSM.g:3131:1: ( rule__SimpleState__Group_3_3__0 )?
+            int alt38=2;
+            int LA38_0 = input.LA(1);
 
-            if ( (LA37_0==35) ) {
-                alt37=1;
+            if ( (LA38_0==35) ) {
+                alt38=1;
             }
-            switch (alt37) {
+            switch (alt38) {
                 case 1 :
-                    // InternalFSM.g:3084:2: rule__SimpleState__Group_3_3__0
+                    // InternalFSM.g:3131:2: rule__SimpleState__Group_3_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_3__0();
@@ -9297,14 +9453,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__4"
-    // InternalFSM.g:3094:1: rule__SimpleState__Group_3__4 : rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ;
+    // InternalFSM.g:3141:1: rule__SimpleState__Group_3__4 : rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ;
     public final void rule__SimpleState__Group_3__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3098:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 )
-            // InternalFSM.g:3099:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5
+            // InternalFSM.g:3145:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 )
+            // InternalFSM.g:3146:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5
             {
             pushFollow(FOLLOW_11);
             rule__SimpleState__Group_3__4__Impl();
@@ -9335,29 +9491,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__4__Impl"
-    // InternalFSM.g:3106:1: rule__SimpleState__Group_3__4__Impl : ( ( rule__SimpleState__Group_3_4__0 )? ) ;
+    // InternalFSM.g:3153:1: rule__SimpleState__Group_3__4__Impl : ( ( rule__SimpleState__Group_3_4__0 )? ) ;
     public final void rule__SimpleState__Group_3__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3110:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) )
-            // InternalFSM.g:3111:1: ( ( rule__SimpleState__Group_3_4__0 )? )
+            // InternalFSM.g:3157:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) )
+            // InternalFSM.g:3158:1: ( ( rule__SimpleState__Group_3_4__0 )? )
             {
-            // InternalFSM.g:3111:1: ( ( rule__SimpleState__Group_3_4__0 )? )
-            // InternalFSM.g:3112:1: ( rule__SimpleState__Group_3_4__0 )?
+            // InternalFSM.g:3158:1: ( ( rule__SimpleState__Group_3_4__0 )? )
+            // InternalFSM.g:3159:1: ( rule__SimpleState__Group_3_4__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_4()); 
-            // InternalFSM.g:3113:1: ( rule__SimpleState__Group_3_4__0 )?
-            int alt38=2;
-            int LA38_0 = input.LA(1);
+            // InternalFSM.g:3160:1: ( rule__SimpleState__Group_3_4__0 )?
+            int alt39=2;
+            int LA39_0 = input.LA(1);
 
-            if ( (LA38_0==36) ) {
-                alt38=1;
+            if ( (LA39_0==36) ) {
+                alt39=1;
             }
-            switch (alt38) {
+            switch (alt39) {
                 case 1 :
-                    // InternalFSM.g:3113:2: rule__SimpleState__Group_3_4__0
+                    // InternalFSM.g:3160:2: rule__SimpleState__Group_3_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_4__0();
@@ -9393,14 +9549,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__5"
-    // InternalFSM.g:3123:1: rule__SimpleState__Group_3__5 : rule__SimpleState__Group_3__5__Impl ;
+    // InternalFSM.g:3170:1: rule__SimpleState__Group_3__5 : rule__SimpleState__Group_3__5__Impl ;
     public final void rule__SimpleState__Group_3__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3127:1: ( rule__SimpleState__Group_3__5__Impl )
-            // InternalFSM.g:3128:2: rule__SimpleState__Group_3__5__Impl
+            // InternalFSM.g:3174:1: ( rule__SimpleState__Group_3__5__Impl )
+            // InternalFSM.g:3175:2: rule__SimpleState__Group_3__5__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3__5__Impl();
@@ -9426,17 +9582,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__5__Impl"
-    // InternalFSM.g:3134:1: rule__SimpleState__Group_3__5__Impl : ( '}' ) ;
+    // InternalFSM.g:3181:1: rule__SimpleState__Group_3__5__Impl : ( '}' ) ;
     public final void rule__SimpleState__Group_3__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3138:1: ( ( '}' ) )
-            // InternalFSM.g:3139:1: ( '}' )
+            // InternalFSM.g:3185:1: ( ( '}' ) )
+            // InternalFSM.g:3186:1: ( '}' )
             {
-            // InternalFSM.g:3139:1: ( '}' )
-            // InternalFSM.g:3140:1: '}'
+            // InternalFSM.g:3186:1: ( '}' )
+            // InternalFSM.g:3187:1: '}'
             {
              before(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); 
             match(input,30,FOLLOW_2); 
@@ -9463,14 +9619,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__0"
-    // InternalFSM.g:3165:1: rule__SimpleState__Group_3_1__0 : rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ;
+    // InternalFSM.g:3212:1: rule__SimpleState__Group_3_1__0 : rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ;
     public final void rule__SimpleState__Group_3_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3169:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 )
-            // InternalFSM.g:3170:2: rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1
+            // InternalFSM.g:3216:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 )
+            // InternalFSM.g:3217:2: rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1
             {
             pushFollow(FOLLOW_12);
             rule__SimpleState__Group_3_1__0__Impl();
@@ -9501,17 +9657,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__0__Impl"
-    // InternalFSM.g:3177:1: rule__SimpleState__Group_3_1__0__Impl : ( 'entry' ) ;
+    // InternalFSM.g:3224:1: rule__SimpleState__Group_3_1__0__Impl : ( 'entry' ) ;
     public final void rule__SimpleState__Group_3_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3181:1: ( ( 'entry' ) )
-            // InternalFSM.g:3182:1: ( 'entry' )
+            // InternalFSM.g:3228:1: ( ( 'entry' ) )
+            // InternalFSM.g:3229:1: ( 'entry' )
             {
-            // InternalFSM.g:3182:1: ( 'entry' )
-            // InternalFSM.g:3183:1: 'entry'
+            // InternalFSM.g:3229:1: ( 'entry' )
+            // InternalFSM.g:3230:1: 'entry'
             {
              before(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); 
             match(input,33,FOLLOW_2); 
@@ -9538,14 +9694,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__1"
-    // InternalFSM.g:3196:1: rule__SimpleState__Group_3_1__1 : rule__SimpleState__Group_3_1__1__Impl ;
+    // InternalFSM.g:3243:1: rule__SimpleState__Group_3_1__1 : rule__SimpleState__Group_3_1__1__Impl ;
     public final void rule__SimpleState__Group_3_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3200:1: ( rule__SimpleState__Group_3_1__1__Impl )
-            // InternalFSM.g:3201:2: rule__SimpleState__Group_3_1__1__Impl
+            // InternalFSM.g:3247:1: ( rule__SimpleState__Group_3_1__1__Impl )
+            // InternalFSM.g:3248:2: rule__SimpleState__Group_3_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_1__1__Impl();
@@ -9571,21 +9727,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__1__Impl"
-    // InternalFSM.g:3207:1: rule__SimpleState__Group_3_1__1__Impl : ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ;
+    // InternalFSM.g:3254:1: rule__SimpleState__Group_3_1__1__Impl : ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ;
     public final void rule__SimpleState__Group_3_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3211:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) )
-            // InternalFSM.g:3212:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
+            // InternalFSM.g:3258:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) )
+            // InternalFSM.g:3259:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
             {
-            // InternalFSM.g:3212:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
-            // InternalFSM.g:3213:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
+            // InternalFSM.g:3259:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
+            // InternalFSM.g:3260:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); 
-            // InternalFSM.g:3214:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
-            // InternalFSM.g:3214:2: rule__SimpleState__EntryCodeAssignment_3_1_1
+            // InternalFSM.g:3261:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
+            // InternalFSM.g:3261:2: rule__SimpleState__EntryCodeAssignment_3_1_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__EntryCodeAssignment_3_1_1();
@@ -9618,14 +9774,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__0"
-    // InternalFSM.g:3228:1: rule__SimpleState__Group_3_2__0 : rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ;
+    // InternalFSM.g:3275:1: rule__SimpleState__Group_3_2__0 : rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ;
     public final void rule__SimpleState__Group_3_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3232:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 )
-            // InternalFSM.g:3233:2: rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1
+            // InternalFSM.g:3279:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 )
+            // InternalFSM.g:3280:2: rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1
             {
             pushFollow(FOLLOW_12);
             rule__SimpleState__Group_3_2__0__Impl();
@@ -9656,17 +9812,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__0__Impl"
-    // InternalFSM.g:3240:1: rule__SimpleState__Group_3_2__0__Impl : ( 'exit' ) ;
+    // InternalFSM.g:3287:1: rule__SimpleState__Group_3_2__0__Impl : ( 'exit' ) ;
     public final void rule__SimpleState__Group_3_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3244:1: ( ( 'exit' ) )
-            // InternalFSM.g:3245:1: ( 'exit' )
+            // InternalFSM.g:3291:1: ( ( 'exit' ) )
+            // InternalFSM.g:3292:1: ( 'exit' )
             {
-            // InternalFSM.g:3245:1: ( 'exit' )
-            // InternalFSM.g:3246:1: 'exit'
+            // InternalFSM.g:3292:1: ( 'exit' )
+            // InternalFSM.g:3293:1: 'exit'
             {
              before(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); 
             match(input,34,FOLLOW_2); 
@@ -9693,14 +9849,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__1"
-    // InternalFSM.g:3259:1: rule__SimpleState__Group_3_2__1 : rule__SimpleState__Group_3_2__1__Impl ;
+    // InternalFSM.g:3306:1: rule__SimpleState__Group_3_2__1 : rule__SimpleState__Group_3_2__1__Impl ;
     public final void rule__SimpleState__Group_3_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3263:1: ( rule__SimpleState__Group_3_2__1__Impl )
-            // InternalFSM.g:3264:2: rule__SimpleState__Group_3_2__1__Impl
+            // InternalFSM.g:3310:1: ( rule__SimpleState__Group_3_2__1__Impl )
+            // InternalFSM.g:3311:2: rule__SimpleState__Group_3_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_2__1__Impl();
@@ -9726,21 +9882,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__1__Impl"
-    // InternalFSM.g:3270:1: rule__SimpleState__Group_3_2__1__Impl : ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ;
+    // InternalFSM.g:3317:1: rule__SimpleState__Group_3_2__1__Impl : ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ;
     public final void rule__SimpleState__Group_3_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3274:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) )
-            // InternalFSM.g:3275:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
+            // InternalFSM.g:3321:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) )
+            // InternalFSM.g:3322:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
             {
-            // InternalFSM.g:3275:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
-            // InternalFSM.g:3276:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
+            // InternalFSM.g:3322:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
+            // InternalFSM.g:3323:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); 
-            // InternalFSM.g:3277:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
-            // InternalFSM.g:3277:2: rule__SimpleState__ExitCodeAssignment_3_2_1
+            // InternalFSM.g:3324:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
+            // InternalFSM.g:3324:2: rule__SimpleState__ExitCodeAssignment_3_2_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__ExitCodeAssignment_3_2_1();
@@ -9773,14 +9929,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__0"
-    // InternalFSM.g:3291:1: rule__SimpleState__Group_3_3__0 : rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ;
+    // InternalFSM.g:3338:1: rule__SimpleState__Group_3_3__0 : rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ;
     public final void rule__SimpleState__Group_3_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3295:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 )
-            // InternalFSM.g:3296:2: rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1
+            // InternalFSM.g:3342:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 )
+            // InternalFSM.g:3343:2: rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1
             {
             pushFollow(FOLLOW_12);
             rule__SimpleState__Group_3_3__0__Impl();
@@ -9811,17 +9967,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__0__Impl"
-    // InternalFSM.g:3303:1: rule__SimpleState__Group_3_3__0__Impl : ( 'do' ) ;
+    // InternalFSM.g:3350:1: rule__SimpleState__Group_3_3__0__Impl : ( 'do' ) ;
     public final void rule__SimpleState__Group_3_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3307:1: ( ( 'do' ) )
-            // InternalFSM.g:3308:1: ( 'do' )
+            // InternalFSM.g:3354:1: ( ( 'do' ) )
+            // InternalFSM.g:3355:1: ( 'do' )
             {
-            // InternalFSM.g:3308:1: ( 'do' )
-            // InternalFSM.g:3309:1: 'do'
+            // InternalFSM.g:3355:1: ( 'do' )
+            // InternalFSM.g:3356:1: 'do'
             {
              before(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); 
             match(input,35,FOLLOW_2); 
@@ -9848,14 +10004,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__1"
-    // InternalFSM.g:3322:1: rule__SimpleState__Group_3_3__1 : rule__SimpleState__Group_3_3__1__Impl ;
+    // InternalFSM.g:3369:1: rule__SimpleState__Group_3_3__1 : rule__SimpleState__Group_3_3__1__Impl ;
     public final void rule__SimpleState__Group_3_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3326:1: ( rule__SimpleState__Group_3_3__1__Impl )
-            // InternalFSM.g:3327:2: rule__SimpleState__Group_3_3__1__Impl
+            // InternalFSM.g:3373:1: ( rule__SimpleState__Group_3_3__1__Impl )
+            // InternalFSM.g:3374:2: rule__SimpleState__Group_3_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_3__1__Impl();
@@ -9881,21 +10037,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__1__Impl"
-    // InternalFSM.g:3333:1: rule__SimpleState__Group_3_3__1__Impl : ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ;
+    // InternalFSM.g:3380:1: rule__SimpleState__Group_3_3__1__Impl : ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ;
     public final void rule__SimpleState__Group_3_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3337:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) )
-            // InternalFSM.g:3338:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
+            // InternalFSM.g:3384:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) )
+            // InternalFSM.g:3385:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
             {
-            // InternalFSM.g:3338:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
-            // InternalFSM.g:3339:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
+            // InternalFSM.g:3385:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
+            // InternalFSM.g:3386:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); 
-            // InternalFSM.g:3340:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
-            // InternalFSM.g:3340:2: rule__SimpleState__DoCodeAssignment_3_3_1
+            // InternalFSM.g:3387:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
+            // InternalFSM.g:3387:2: rule__SimpleState__DoCodeAssignment_3_3_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__DoCodeAssignment_3_3_1();
@@ -9928,14 +10084,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__0"
-    // InternalFSM.g:3354:1: rule__SimpleState__Group_3_4__0 : rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ;
+    // InternalFSM.g:3401:1: rule__SimpleState__Group_3_4__0 : rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ;
     public final void rule__SimpleState__Group_3_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3358:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 )
-            // InternalFSM.g:3359:2: rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1
+            // InternalFSM.g:3405:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 )
+            // InternalFSM.g:3406:2: rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1
             {
             pushFollow(FOLLOW_7);
             rule__SimpleState__Group_3_4__0__Impl();
@@ -9966,17 +10122,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__0__Impl"
-    // InternalFSM.g:3366:1: rule__SimpleState__Group_3_4__0__Impl : ( 'subgraph' ) ;
+    // InternalFSM.g:3413:1: rule__SimpleState__Group_3_4__0__Impl : ( 'subgraph' ) ;
     public final void rule__SimpleState__Group_3_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3370:1: ( ( 'subgraph' ) )
-            // InternalFSM.g:3371:1: ( 'subgraph' )
+            // InternalFSM.g:3417:1: ( ( 'subgraph' ) )
+            // InternalFSM.g:3418:1: ( 'subgraph' )
             {
-            // InternalFSM.g:3371:1: ( 'subgraph' )
-            // InternalFSM.g:3372:1: 'subgraph'
+            // InternalFSM.g:3418:1: ( 'subgraph' )
+            // InternalFSM.g:3419:1: 'subgraph'
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); 
             match(input,36,FOLLOW_2); 
@@ -10003,14 +10159,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__1"
-    // InternalFSM.g:3385:1: rule__SimpleState__Group_3_4__1 : rule__SimpleState__Group_3_4__1__Impl ;
+    // InternalFSM.g:3432:1: rule__SimpleState__Group_3_4__1 : rule__SimpleState__Group_3_4__1__Impl ;
     public final void rule__SimpleState__Group_3_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3389:1: ( rule__SimpleState__Group_3_4__1__Impl )
-            // InternalFSM.g:3390:2: rule__SimpleState__Group_3_4__1__Impl
+            // InternalFSM.g:3436:1: ( rule__SimpleState__Group_3_4__1__Impl )
+            // InternalFSM.g:3437:2: rule__SimpleState__Group_3_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_4__1__Impl();
@@ -10036,21 +10192,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__1__Impl"
-    // InternalFSM.g:3396:1: rule__SimpleState__Group_3_4__1__Impl : ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ;
+    // InternalFSM.g:3443:1: rule__SimpleState__Group_3_4__1__Impl : ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ;
     public final void rule__SimpleState__Group_3_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3400:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) )
-            // InternalFSM.g:3401:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
+            // InternalFSM.g:3447:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) )
+            // InternalFSM.g:3448:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
             {
-            // InternalFSM.g:3401:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
-            // InternalFSM.g:3402:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
+            // InternalFSM.g:3448:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
+            // InternalFSM.g:3449:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); 
-            // InternalFSM.g:3403:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
-            // InternalFSM.g:3403:2: rule__SimpleState__SubgraphAssignment_3_4_1
+            // InternalFSM.g:3450:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
+            // InternalFSM.g:3450:2: rule__SimpleState__SubgraphAssignment_3_4_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__SubgraphAssignment_3_4_1();
@@ -10083,14 +10239,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__0"
-    // InternalFSM.g:3417:1: rule__RefinedState__Group__0 : rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ;
+    // InternalFSM.g:3464:1: rule__RefinedState__Group__0 : rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ;
     public final void rule__RefinedState__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3421:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 )
-            // InternalFSM.g:3422:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1
+            // InternalFSM.g:3468:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 )
+            // InternalFSM.g:3469:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__RefinedState__Group__0__Impl();
@@ -10121,17 +10277,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__0__Impl"
-    // InternalFSM.g:3429:1: rule__RefinedState__Group__0__Impl : ( 'RefinedState' ) ;
+    // InternalFSM.g:3476:1: rule__RefinedState__Group__0__Impl : ( 'RefinedState' ) ;
     public final void rule__RefinedState__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3433:1: ( ( 'RefinedState' ) )
-            // InternalFSM.g:3434:1: ( 'RefinedState' )
+            // InternalFSM.g:3480:1: ( ( 'RefinedState' ) )
+            // InternalFSM.g:3481:1: ( 'RefinedState' )
             {
-            // InternalFSM.g:3434:1: ( 'RefinedState' )
-            // InternalFSM.g:3435:1: 'RefinedState'
+            // InternalFSM.g:3481:1: ( 'RefinedState' )
+            // InternalFSM.g:3482:1: 'RefinedState'
             {
              before(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); 
             match(input,37,FOLLOW_2); 
@@ -10158,14 +10314,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__1"
-    // InternalFSM.g:3448:1: rule__RefinedState__Group__1 : rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ;
+    // InternalFSM.g:3495:1: rule__RefinedState__Group__1 : rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ;
     public final void rule__RefinedState__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3452:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 )
-            // InternalFSM.g:3453:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2
+            // InternalFSM.g:3499:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 )
+            // InternalFSM.g:3500:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2
             {
             pushFollow(FOLLOW_10);
             rule__RefinedState__Group__1__Impl();
@@ -10196,21 +10352,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__1__Impl"
-    // InternalFSM.g:3460:1: rule__RefinedState__Group__1__Impl : ( ( rule__RefinedState__TargetAssignment_1 ) ) ;
+    // InternalFSM.g:3507:1: rule__RefinedState__Group__1__Impl : ( ( rule__RefinedState__TargetAssignment_1 ) ) ;
     public final void rule__RefinedState__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3464:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) )
-            // InternalFSM.g:3465:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
+            // InternalFSM.g:3511:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) )
+            // InternalFSM.g:3512:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
             {
-            // InternalFSM.g:3465:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
-            // InternalFSM.g:3466:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalFSM.g:3512:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
+            // InternalFSM.g:3513:1: ( rule__RefinedState__TargetAssignment_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); 
-            // InternalFSM.g:3467:1: ( rule__RefinedState__TargetAssignment_1 )
-            // InternalFSM.g:3467:2: rule__RefinedState__TargetAssignment_1
+            // InternalFSM.g:3514:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalFSM.g:3514:2: rule__RefinedState__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__TargetAssignment_1();
@@ -10243,14 +10399,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__2"
-    // InternalFSM.g:3477:1: rule__RefinedState__Group__2 : rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ;
+    // InternalFSM.g:3524:1: rule__RefinedState__Group__2 : rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ;
     public final void rule__RefinedState__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3481:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 )
-            // InternalFSM.g:3482:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3
+            // InternalFSM.g:3528:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 )
+            // InternalFSM.g:3529:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3
             {
             pushFollow(FOLLOW_10);
             rule__RefinedState__Group__2__Impl();
@@ -10281,29 +10437,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__2__Impl"
-    // InternalFSM.g:3489:1: rule__RefinedState__Group__2__Impl : ( ( rule__RefinedState__DocuAssignment_2 )? ) ;
+    // InternalFSM.g:3536:1: rule__RefinedState__Group__2__Impl : ( ( rule__RefinedState__DocuAssignment_2 )? ) ;
     public final void rule__RefinedState__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3493:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) )
-            // InternalFSM.g:3494:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
+            // InternalFSM.g:3540:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) )
+            // InternalFSM.g:3541:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
             {
-            // InternalFSM.g:3494:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
-            // InternalFSM.g:3495:1: ( rule__RefinedState__DocuAssignment_2 )?
+            // InternalFSM.g:3541:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
+            // InternalFSM.g:3542:1: ( rule__RefinedState__DocuAssignment_2 )?
             {
              before(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); 
-            // InternalFSM.g:3496:1: ( rule__RefinedState__DocuAssignment_2 )?
-            int alt39=2;
-            int LA39_0 = input.LA(1);
+            // InternalFSM.g:3543:1: ( rule__RefinedState__DocuAssignment_2 )?
+            int alt40=2;
+            int LA40_0 = input.LA(1);
 
-            if ( (LA39_0==66) ) {
-                alt39=1;
+            if ( (LA40_0==66) ) {
+                alt40=1;
             }
-            switch (alt39) {
+            switch (alt40) {
                 case 1 :
-                    // InternalFSM.g:3496:2: rule__RefinedState__DocuAssignment_2
+                    // InternalFSM.g:3543:2: rule__RefinedState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__DocuAssignment_2();
@@ -10339,14 +10495,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__3"
-    // InternalFSM.g:3506:1: rule__RefinedState__Group__3 : rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ;
+    // InternalFSM.g:3553:1: rule__RefinedState__Group__3 : rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ;
     public final void rule__RefinedState__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3510:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 )
-            // InternalFSM.g:3511:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4
+            // InternalFSM.g:3557:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 )
+            // InternalFSM.g:3558:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__RefinedState__Group__3__Impl();
@@ -10377,17 +10533,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__3__Impl"
-    // InternalFSM.g:3518:1: rule__RefinedState__Group__3__Impl : ( '{' ) ;
+    // InternalFSM.g:3565:1: rule__RefinedState__Group__3__Impl : ( '{' ) ;
     public final void rule__RefinedState__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3522:1: ( ( '{' ) )
-            // InternalFSM.g:3523:1: ( '{' )
+            // InternalFSM.g:3569:1: ( ( '{' ) )
+            // InternalFSM.g:3570:1: ( '{' )
             {
-            // InternalFSM.g:3523:1: ( '{' )
-            // InternalFSM.g:3524:1: '{'
+            // InternalFSM.g:3570:1: ( '{' )
+            // InternalFSM.g:3571:1: '{'
             {
              before(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,29,FOLLOW_2); 
@@ -10414,14 +10570,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__4"
-    // InternalFSM.g:3537:1: rule__RefinedState__Group__4 : rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ;
+    // InternalFSM.g:3584:1: rule__RefinedState__Group__4 : rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ;
     public final void rule__RefinedState__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3541:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 )
-            // InternalFSM.g:3542:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5
+            // InternalFSM.g:3588:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 )
+            // InternalFSM.g:3589:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5
             {
             pushFollow(FOLLOW_11);
             rule__RefinedState__Group__4__Impl();
@@ -10452,29 +10608,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__4__Impl"
-    // InternalFSM.g:3549:1: rule__RefinedState__Group__4__Impl : ( ( rule__RefinedState__Group_4__0 )? ) ;
+    // InternalFSM.g:3596:1: rule__RefinedState__Group__4__Impl : ( ( rule__RefinedState__Group_4__0 )? ) ;
     public final void rule__RefinedState__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3553:1: ( ( ( rule__RefinedState__Group_4__0 )? ) )
-            // InternalFSM.g:3554:1: ( ( rule__RefinedState__Group_4__0 )? )
+            // InternalFSM.g:3600:1: ( ( ( rule__RefinedState__Group_4__0 )? ) )
+            // InternalFSM.g:3601:1: ( ( rule__RefinedState__Group_4__0 )? )
             {
-            // InternalFSM.g:3554:1: ( ( rule__RefinedState__Group_4__0 )? )
-            // InternalFSM.g:3555:1: ( rule__RefinedState__Group_4__0 )?
+            // InternalFSM.g:3601:1: ( ( rule__RefinedState__Group_4__0 )? )
+            // InternalFSM.g:3602:1: ( rule__RefinedState__Group_4__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_4()); 
-            // InternalFSM.g:3556:1: ( rule__RefinedState__Group_4__0 )?
-            int alt40=2;
-            int LA40_0 = input.LA(1);
+            // InternalFSM.g:3603:1: ( rule__RefinedState__Group_4__0 )?
+            int alt41=2;
+            int LA41_0 = input.LA(1);
 
-            if ( (LA40_0==33) ) {
-                alt40=1;
+            if ( (LA41_0==33) ) {
+                alt41=1;
             }
-            switch (alt40) {
+            switch (alt41) {
                 case 1 :
-                    // InternalFSM.g:3556:2: rule__RefinedState__Group_4__0
+                    // InternalFSM.g:3603:2: rule__RefinedState__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_4__0();
@@ -10510,14 +10666,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__5"
-    // InternalFSM.g:3566:1: rule__RefinedState__Group__5 : rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ;
+    // InternalFSM.g:3613:1: rule__RefinedState__Group__5 : rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ;
     public final void rule__RefinedState__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3570:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 )
-            // InternalFSM.g:3571:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6
+            // InternalFSM.g:3617:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 )
+            // InternalFSM.g:3618:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6
             {
             pushFollow(FOLLOW_11);
             rule__RefinedState__Group__5__Impl();
@@ -10548,29 +10704,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__5__Impl"
-    // InternalFSM.g:3578:1: rule__RefinedState__Group__5__Impl : ( ( rule__RefinedState__Group_5__0 )? ) ;
+    // InternalFSM.g:3625:1: rule__RefinedState__Group__5__Impl : ( ( rule__RefinedState__Group_5__0 )? ) ;
     public final void rule__RefinedState__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3582:1: ( ( ( rule__RefinedState__Group_5__0 )? ) )
-            // InternalFSM.g:3583:1: ( ( rule__RefinedState__Group_5__0 )? )
+            // InternalFSM.g:3629:1: ( ( ( rule__RefinedState__Group_5__0 )? ) )
+            // InternalFSM.g:3630:1: ( ( rule__RefinedState__Group_5__0 )? )
             {
-            // InternalFSM.g:3583:1: ( ( rule__RefinedState__Group_5__0 )? )
-            // InternalFSM.g:3584:1: ( rule__RefinedState__Group_5__0 )?
+            // InternalFSM.g:3630:1: ( ( rule__RefinedState__Group_5__0 )? )
+            // InternalFSM.g:3631:1: ( rule__RefinedState__Group_5__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_5()); 
-            // InternalFSM.g:3585:1: ( rule__RefinedState__Group_5__0 )?
-            int alt41=2;
-            int LA41_0 = input.LA(1);
+            // InternalFSM.g:3632:1: ( rule__RefinedState__Group_5__0 )?
+            int alt42=2;
+            int LA42_0 = input.LA(1);
 
-            if ( (LA41_0==34) ) {
-                alt41=1;
+            if ( (LA42_0==34) ) {
+                alt42=1;
             }
-            switch (alt41) {
+            switch (alt42) {
                 case 1 :
-                    // InternalFSM.g:3585:2: rule__RefinedState__Group_5__0
+                    // InternalFSM.g:3632:2: rule__RefinedState__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_5__0();
@@ -10606,14 +10762,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__6"
-    // InternalFSM.g:3595:1: rule__RefinedState__Group__6 : rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ;
+    // InternalFSM.g:3642:1: rule__RefinedState__Group__6 : rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ;
     public final void rule__RefinedState__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3599:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 )
-            // InternalFSM.g:3600:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7
+            // InternalFSM.g:3646:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 )
+            // InternalFSM.g:3647:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7
             {
             pushFollow(FOLLOW_11);
             rule__RefinedState__Group__6__Impl();
@@ -10644,29 +10800,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__6__Impl"
-    // InternalFSM.g:3607:1: rule__RefinedState__Group__6__Impl : ( ( rule__RefinedState__Group_6__0 )? ) ;
+    // InternalFSM.g:3654:1: rule__RefinedState__Group__6__Impl : ( ( rule__RefinedState__Group_6__0 )? ) ;
     public final void rule__RefinedState__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3611:1: ( ( ( rule__RefinedState__Group_6__0 )? ) )
-            // InternalFSM.g:3612:1: ( ( rule__RefinedState__Group_6__0 )? )
+            // InternalFSM.g:3658:1: ( ( ( rule__RefinedState__Group_6__0 )? ) )
+            // InternalFSM.g:3659:1: ( ( rule__RefinedState__Group_6__0 )? )
             {
-            // InternalFSM.g:3612:1: ( ( rule__RefinedState__Group_6__0 )? )
-            // InternalFSM.g:3613:1: ( rule__RefinedState__Group_6__0 )?
+            // InternalFSM.g:3659:1: ( ( rule__RefinedState__Group_6__0 )? )
+            // InternalFSM.g:3660:1: ( rule__RefinedState__Group_6__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_6()); 
-            // InternalFSM.g:3614:1: ( rule__RefinedState__Group_6__0 )?
-            int alt42=2;
-            int LA42_0 = input.LA(1);
+            // InternalFSM.g:3661:1: ( rule__RefinedState__Group_6__0 )?
+            int alt43=2;
+            int LA43_0 = input.LA(1);
 
-            if ( (LA42_0==35) ) {
-                alt42=1;
+            if ( (LA43_0==35) ) {
+                alt43=1;
             }
-            switch (alt42) {
+            switch (alt43) {
                 case 1 :
-                    // InternalFSM.g:3614:2: rule__RefinedState__Group_6__0
+                    // InternalFSM.g:3661:2: rule__RefinedState__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_6__0();
@@ -10702,14 +10858,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__7"
-    // InternalFSM.g:3624:1: rule__RefinedState__Group__7 : rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ;
+    // InternalFSM.g:3671:1: rule__RefinedState__Group__7 : rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ;
     public final void rule__RefinedState__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3628:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 )
-            // InternalFSM.g:3629:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8
+            // InternalFSM.g:3675:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 )
+            // InternalFSM.g:3676:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8
             {
             pushFollow(FOLLOW_11);
             rule__RefinedState__Group__7__Impl();
@@ -10740,29 +10896,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__7__Impl"
-    // InternalFSM.g:3636:1: rule__RefinedState__Group__7__Impl : ( ( rule__RefinedState__Group_7__0 )? ) ;
+    // InternalFSM.g:3683:1: rule__RefinedState__Group__7__Impl : ( ( rule__RefinedState__Group_7__0 )? ) ;
     public final void rule__RefinedState__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3640:1: ( ( ( rule__RefinedState__Group_7__0 )? ) )
-            // InternalFSM.g:3641:1: ( ( rule__RefinedState__Group_7__0 )? )
+            // InternalFSM.g:3687:1: ( ( ( rule__RefinedState__Group_7__0 )? ) )
+            // InternalFSM.g:3688:1: ( ( rule__RefinedState__Group_7__0 )? )
             {
-            // InternalFSM.g:3641:1: ( ( rule__RefinedState__Group_7__0 )? )
-            // InternalFSM.g:3642:1: ( rule__RefinedState__Group_7__0 )?
+            // InternalFSM.g:3688:1: ( ( rule__RefinedState__Group_7__0 )? )
+            // InternalFSM.g:3689:1: ( rule__RefinedState__Group_7__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_7()); 
-            // InternalFSM.g:3643:1: ( rule__RefinedState__Group_7__0 )?
-            int alt43=2;
-            int LA43_0 = input.LA(1);
+            // InternalFSM.g:3690:1: ( rule__RefinedState__Group_7__0 )?
+            int alt44=2;
+            int LA44_0 = input.LA(1);
 
-            if ( (LA43_0==36) ) {
-                alt43=1;
+            if ( (LA44_0==36) ) {
+                alt44=1;
             }
-            switch (alt43) {
+            switch (alt44) {
                 case 1 :
-                    // InternalFSM.g:3643:2: rule__RefinedState__Group_7__0
+                    // InternalFSM.g:3690:2: rule__RefinedState__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_7__0();
@@ -10798,14 +10954,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__8"
-    // InternalFSM.g:3653:1: rule__RefinedState__Group__8 : rule__RefinedState__Group__8__Impl ;
+    // InternalFSM.g:3700:1: rule__RefinedState__Group__8 : rule__RefinedState__Group__8__Impl ;
     public final void rule__RefinedState__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3657:1: ( rule__RefinedState__Group__8__Impl )
-            // InternalFSM.g:3658:2: rule__RefinedState__Group__8__Impl
+            // InternalFSM.g:3704:1: ( rule__RefinedState__Group__8__Impl )
+            // InternalFSM.g:3705:2: rule__RefinedState__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group__8__Impl();
@@ -10831,17 +10987,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__8__Impl"
-    // InternalFSM.g:3664:1: rule__RefinedState__Group__8__Impl : ( '}' ) ;
+    // InternalFSM.g:3711:1: rule__RefinedState__Group__8__Impl : ( '}' ) ;
     public final void rule__RefinedState__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3668:1: ( ( '}' ) )
-            // InternalFSM.g:3669:1: ( '}' )
+            // InternalFSM.g:3715:1: ( ( '}' ) )
+            // InternalFSM.g:3716:1: ( '}' )
             {
-            // InternalFSM.g:3669:1: ( '}' )
-            // InternalFSM.g:3670:1: '}'
+            // InternalFSM.g:3716:1: ( '}' )
+            // InternalFSM.g:3717:1: '}'
             {
              before(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); 
             match(input,30,FOLLOW_2); 
@@ -10868,14 +11024,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__0"
-    // InternalFSM.g:3701:1: rule__RefinedState__Group_4__0 : rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ;
+    // InternalFSM.g:3748:1: rule__RefinedState__Group_4__0 : rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ;
     public final void rule__RefinedState__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3705:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 )
-            // InternalFSM.g:3706:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1
+            // InternalFSM.g:3752:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 )
+            // InternalFSM.g:3753:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1
             {
             pushFollow(FOLLOW_12);
             rule__RefinedState__Group_4__0__Impl();
@@ -10906,17 +11062,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__0__Impl"
-    // InternalFSM.g:3713:1: rule__RefinedState__Group_4__0__Impl : ( 'entry' ) ;
+    // InternalFSM.g:3760:1: rule__RefinedState__Group_4__0__Impl : ( 'entry' ) ;
     public final void rule__RefinedState__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3717:1: ( ( 'entry' ) )
-            // InternalFSM.g:3718:1: ( 'entry' )
+            // InternalFSM.g:3764:1: ( ( 'entry' ) )
+            // InternalFSM.g:3765:1: ( 'entry' )
             {
-            // InternalFSM.g:3718:1: ( 'entry' )
-            // InternalFSM.g:3719:1: 'entry'
+            // InternalFSM.g:3765:1: ( 'entry' )
+            // InternalFSM.g:3766:1: 'entry'
             {
              before(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); 
             match(input,33,FOLLOW_2); 
@@ -10943,14 +11099,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__1"
-    // InternalFSM.g:3732:1: rule__RefinedState__Group_4__1 : rule__RefinedState__Group_4__1__Impl ;
+    // InternalFSM.g:3779:1: rule__RefinedState__Group_4__1 : rule__RefinedState__Group_4__1__Impl ;
     public final void rule__RefinedState__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3736:1: ( rule__RefinedState__Group_4__1__Impl )
-            // InternalFSM.g:3737:2: rule__RefinedState__Group_4__1__Impl
+            // InternalFSM.g:3783:1: ( rule__RefinedState__Group_4__1__Impl )
+            // InternalFSM.g:3784:2: rule__RefinedState__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_4__1__Impl();
@@ -10976,21 +11132,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__1__Impl"
-    // InternalFSM.g:3743:1: rule__RefinedState__Group_4__1__Impl : ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ;
+    // InternalFSM.g:3790:1: rule__RefinedState__Group_4__1__Impl : ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ;
     public final void rule__RefinedState__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3747:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) )
-            // InternalFSM.g:3748:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
+            // InternalFSM.g:3794:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) )
+            // InternalFSM.g:3795:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
             {
-            // InternalFSM.g:3748:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
-            // InternalFSM.g:3749:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
+            // InternalFSM.g:3795:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
+            // InternalFSM.g:3796:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); 
-            // InternalFSM.g:3750:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
-            // InternalFSM.g:3750:2: rule__RefinedState__EntryCodeAssignment_4_1
+            // InternalFSM.g:3797:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
+            // InternalFSM.g:3797:2: rule__RefinedState__EntryCodeAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__EntryCodeAssignment_4_1();
@@ -11023,14 +11179,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__0"
-    // InternalFSM.g:3764:1: rule__RefinedState__Group_5__0 : rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ;
+    // InternalFSM.g:3811:1: rule__RefinedState__Group_5__0 : rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ;
     public final void rule__RefinedState__Group_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3768:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 )
-            // InternalFSM.g:3769:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1
+            // InternalFSM.g:3815:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 )
+            // InternalFSM.g:3816:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1
             {
             pushFollow(FOLLOW_12);
             rule__RefinedState__Group_5__0__Impl();
@@ -11061,17 +11217,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__0__Impl"
-    // InternalFSM.g:3776:1: rule__RefinedState__Group_5__0__Impl : ( 'exit' ) ;
+    // InternalFSM.g:3823:1: rule__RefinedState__Group_5__0__Impl : ( 'exit' ) ;
     public final void rule__RefinedState__Group_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3780:1: ( ( 'exit' ) )
-            // InternalFSM.g:3781:1: ( 'exit' )
+            // InternalFSM.g:3827:1: ( ( 'exit' ) )
+            // InternalFSM.g:3828:1: ( 'exit' )
             {
-            // InternalFSM.g:3781:1: ( 'exit' )
-            // InternalFSM.g:3782:1: 'exit'
+            // InternalFSM.g:3828:1: ( 'exit' )
+            // InternalFSM.g:3829:1: 'exit'
             {
              before(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); 
             match(input,34,FOLLOW_2); 
@@ -11098,14 +11254,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__1"
-    // InternalFSM.g:3795:1: rule__RefinedState__Group_5__1 : rule__RefinedState__Group_5__1__Impl ;
+    // InternalFSM.g:3842:1: rule__RefinedState__Group_5__1 : rule__RefinedState__Group_5__1__Impl ;
     public final void rule__RefinedState__Group_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3799:1: ( rule__RefinedState__Group_5__1__Impl )
-            // InternalFSM.g:3800:2: rule__RefinedState__Group_5__1__Impl
+            // InternalFSM.g:3846:1: ( rule__RefinedState__Group_5__1__Impl )
+            // InternalFSM.g:3847:2: rule__RefinedState__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_5__1__Impl();
@@ -11131,21 +11287,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__1__Impl"
-    // InternalFSM.g:3806:1: rule__RefinedState__Group_5__1__Impl : ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ;
+    // InternalFSM.g:3853:1: rule__RefinedState__Group_5__1__Impl : ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ;
     public final void rule__RefinedState__Group_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3810:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) )
-            // InternalFSM.g:3811:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
+            // InternalFSM.g:3857:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) )
+            // InternalFSM.g:3858:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
             {
-            // InternalFSM.g:3811:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
-            // InternalFSM.g:3812:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
+            // InternalFSM.g:3858:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
+            // InternalFSM.g:3859:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); 
-            // InternalFSM.g:3813:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
-            // InternalFSM.g:3813:2: rule__RefinedState__ExitCodeAssignment_5_1
+            // InternalFSM.g:3860:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
+            // InternalFSM.g:3860:2: rule__RefinedState__ExitCodeAssignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__ExitCodeAssignment_5_1();
@@ -11178,14 +11334,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__0"
-    // InternalFSM.g:3827:1: rule__RefinedState__Group_6__0 : rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ;
+    // InternalFSM.g:3874:1: rule__RefinedState__Group_6__0 : rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ;
     public final void rule__RefinedState__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3831:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 )
-            // InternalFSM.g:3832:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1
+            // InternalFSM.g:3878:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 )
+            // InternalFSM.g:3879:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1
             {
             pushFollow(FOLLOW_12);
             rule__RefinedState__Group_6__0__Impl();
@@ -11216,17 +11372,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__0__Impl"
-    // InternalFSM.g:3839:1: rule__RefinedState__Group_6__0__Impl : ( 'do' ) ;
+    // InternalFSM.g:3886:1: rule__RefinedState__Group_6__0__Impl : ( 'do' ) ;
     public final void rule__RefinedState__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3843:1: ( ( 'do' ) )
-            // InternalFSM.g:3844:1: ( 'do' )
+            // InternalFSM.g:3890:1: ( ( 'do' ) )
+            // InternalFSM.g:3891:1: ( 'do' )
             {
-            // InternalFSM.g:3844:1: ( 'do' )
-            // InternalFSM.g:3845:1: 'do'
+            // InternalFSM.g:3891:1: ( 'do' )
+            // InternalFSM.g:3892:1: 'do'
             {
              before(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); 
             match(input,35,FOLLOW_2); 
@@ -11253,14 +11409,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__1"
-    // InternalFSM.g:3858:1: rule__RefinedState__Group_6__1 : rule__RefinedState__Group_6__1__Impl ;
+    // InternalFSM.g:3905:1: rule__RefinedState__Group_6__1 : rule__RefinedState__Group_6__1__Impl ;
     public final void rule__RefinedState__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3862:1: ( rule__RefinedState__Group_6__1__Impl )
-            // InternalFSM.g:3863:2: rule__RefinedState__Group_6__1__Impl
+            // InternalFSM.g:3909:1: ( rule__RefinedState__Group_6__1__Impl )
+            // InternalFSM.g:3910:2: rule__RefinedState__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_6__1__Impl();
@@ -11286,21 +11442,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__1__Impl"
-    // InternalFSM.g:3869:1: rule__RefinedState__Group_6__1__Impl : ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ;
+    // InternalFSM.g:3916:1: rule__RefinedState__Group_6__1__Impl : ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ;
     public final void rule__RefinedState__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3873:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) )
-            // InternalFSM.g:3874:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
+            // InternalFSM.g:3920:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) )
+            // InternalFSM.g:3921:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
             {
-            // InternalFSM.g:3874:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
-            // InternalFSM.g:3875:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
+            // InternalFSM.g:3921:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
+            // InternalFSM.g:3922:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); 
-            // InternalFSM.g:3876:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
-            // InternalFSM.g:3876:2: rule__RefinedState__DoCodeAssignment_6_1
+            // InternalFSM.g:3923:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
+            // InternalFSM.g:3923:2: rule__RefinedState__DoCodeAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__DoCodeAssignment_6_1();
@@ -11333,14 +11489,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__0"
-    // InternalFSM.g:3890:1: rule__RefinedState__Group_7__0 : rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ;
+    // InternalFSM.g:3937:1: rule__RefinedState__Group_7__0 : rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ;
     public final void rule__RefinedState__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3894:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 )
-            // InternalFSM.g:3895:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1
+            // InternalFSM.g:3941:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 )
+            // InternalFSM.g:3942:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1
             {
             pushFollow(FOLLOW_7);
             rule__RefinedState__Group_7__0__Impl();
@@ -11371,17 +11527,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__0__Impl"
-    // InternalFSM.g:3902:1: rule__RefinedState__Group_7__0__Impl : ( 'subgraph' ) ;
+    // InternalFSM.g:3949:1: rule__RefinedState__Group_7__0__Impl : ( 'subgraph' ) ;
     public final void rule__RefinedState__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3906:1: ( ( 'subgraph' ) )
-            // InternalFSM.g:3907:1: ( 'subgraph' )
+            // InternalFSM.g:3953:1: ( ( 'subgraph' ) )
+            // InternalFSM.g:3954:1: ( 'subgraph' )
             {
-            // InternalFSM.g:3907:1: ( 'subgraph' )
-            // InternalFSM.g:3908:1: 'subgraph'
+            // InternalFSM.g:3954:1: ( 'subgraph' )
+            // InternalFSM.g:3955:1: 'subgraph'
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); 
             match(input,36,FOLLOW_2); 
@@ -11408,14 +11564,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__1"
-    // InternalFSM.g:3921:1: rule__RefinedState__Group_7__1 : rule__RefinedState__Group_7__1__Impl ;
+    // InternalFSM.g:3968:1: rule__RefinedState__Group_7__1 : rule__RefinedState__Group_7__1__Impl ;
     public final void rule__RefinedState__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3925:1: ( rule__RefinedState__Group_7__1__Impl )
-            // InternalFSM.g:3926:2: rule__RefinedState__Group_7__1__Impl
+            // InternalFSM.g:3972:1: ( rule__RefinedState__Group_7__1__Impl )
+            // InternalFSM.g:3973:2: rule__RefinedState__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_7__1__Impl();
@@ -11441,21 +11597,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__1__Impl"
-    // InternalFSM.g:3932:1: rule__RefinedState__Group_7__1__Impl : ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ;
+    // InternalFSM.g:3979:1: rule__RefinedState__Group_7__1__Impl : ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ;
     public final void rule__RefinedState__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3936:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) )
-            // InternalFSM.g:3937:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
+            // InternalFSM.g:3983:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) )
+            // InternalFSM.g:3984:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
             {
-            // InternalFSM.g:3937:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
-            // InternalFSM.g:3938:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
+            // InternalFSM.g:3984:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
+            // InternalFSM.g:3985:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); 
-            // InternalFSM.g:3939:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
-            // InternalFSM.g:3939:2: rule__RefinedState__SubgraphAssignment_7_1
+            // InternalFSM.g:3986:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
+            // InternalFSM.g:3986:2: rule__RefinedState__SubgraphAssignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__SubgraphAssignment_7_1();
@@ -11488,14 +11644,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__0"
-    // InternalFSM.g:3953:1: rule__DetailCode__Group_0__0 : rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 ;
+    // InternalFSM.g:4000:1: rule__DetailCode__Group_0__0 : rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 ;
     public final void rule__DetailCode__Group_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3957:1: ( rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 )
-            // InternalFSM.g:3958:2: rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1
+            // InternalFSM.g:4004:1: ( rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 )
+            // InternalFSM.g:4005:2: rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1
             {
             pushFollow(FOLLOW_13);
             rule__DetailCode__Group_0__0__Impl();
@@ -11526,21 +11682,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__0__Impl"
-    // InternalFSM.g:3965:1: rule__DetailCode__Group_0__0__Impl : ( () ) ;
+    // InternalFSM.g:4012:1: rule__DetailCode__Group_0__0__Impl : ( () ) ;
     public final void rule__DetailCode__Group_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3969:1: ( ( () ) )
-            // InternalFSM.g:3970:1: ( () )
+            // InternalFSM.g:4016:1: ( ( () ) )
+            // InternalFSM.g:4017:1: ( () )
             {
-            // InternalFSM.g:3970:1: ( () )
-            // InternalFSM.g:3971:1: ()
+            // InternalFSM.g:4017:1: ( () )
+            // InternalFSM.g:4018:1: ()
             {
              before(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0_0()); 
-            // InternalFSM.g:3972:1: ()
-            // InternalFSM.g:3974:1: 
+            // InternalFSM.g:4019:1: ()
+            // InternalFSM.g:4021:1: 
             {
             }
 
@@ -11563,14 +11719,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__1"
-    // InternalFSM.g:3984:1: rule__DetailCode__Group_0__1 : rule__DetailCode__Group_0__1__Impl ;
+    // InternalFSM.g:4031:1: rule__DetailCode__Group_0__1 : rule__DetailCode__Group_0__1__Impl ;
     public final void rule__DetailCode__Group_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3988:1: ( rule__DetailCode__Group_0__1__Impl )
-            // InternalFSM.g:3989:2: rule__DetailCode__Group_0__1__Impl
+            // InternalFSM.g:4035:1: ( rule__DetailCode__Group_0__1__Impl )
+            // InternalFSM.g:4036:2: rule__DetailCode__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_0__1__Impl();
@@ -11596,29 +11752,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__1__Impl"
-    // InternalFSM.g:3995:1: rule__DetailCode__Group_0__1__Impl : ( ( rule__DetailCode__LinesAssignment_0_1 )? ) ;
+    // InternalFSM.g:4042:1: rule__DetailCode__Group_0__1__Impl : ( ( rule__DetailCode__LinesAssignment_0_1 )? ) ;
     public final void rule__DetailCode__Group_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:3999:1: ( ( ( rule__DetailCode__LinesAssignment_0_1 )? ) )
-            // InternalFSM.g:4000:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
+            // InternalFSM.g:4046:1: ( ( ( rule__DetailCode__LinesAssignment_0_1 )? ) )
+            // InternalFSM.g:4047:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
             {
-            // InternalFSM.g:4000:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
-            // InternalFSM.g:4001:1: ( rule__DetailCode__LinesAssignment_0_1 )?
+            // InternalFSM.g:4047:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
+            // InternalFSM.g:4048:1: ( rule__DetailCode__LinesAssignment_0_1 )?
             {
              before(grammarAccess.getDetailCodeAccess().getLinesAssignment_0_1()); 
-            // InternalFSM.g:4002:1: ( rule__DetailCode__LinesAssignment_0_1 )?
-            int alt44=2;
-            int LA44_0 = input.LA(1);
+            // InternalFSM.g:4049:1: ( rule__DetailCode__LinesAssignment_0_1 )?
+            int alt45=2;
+            int LA45_0 = input.LA(1);
 
-            if ( (LA44_0==RULE_CC_STRING) ) {
-                alt44=1;
+            if ( (LA45_0==RULE_CC_STRING) ) {
+                alt45=1;
             }
-            switch (alt44) {
+            switch (alt45) {
                 case 1 :
-                    // InternalFSM.g:4002:2: rule__DetailCode__LinesAssignment_0_1
+                    // InternalFSM.g:4049:2: rule__DetailCode__LinesAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__LinesAssignment_0_1();
@@ -11654,14 +11810,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__0"
-    // InternalFSM.g:4016:1: rule__DetailCode__Group_1__0 : rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 ;
+    // InternalFSM.g:4063:1: rule__DetailCode__Group_1__0 : rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 ;
     public final void rule__DetailCode__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4020:1: ( rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 )
-            // InternalFSM.g:4021:2: rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1
+            // InternalFSM.g:4067:1: ( rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 )
+            // InternalFSM.g:4068:2: rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1
             {
             pushFollow(FOLLOW_14);
             rule__DetailCode__Group_1__0__Impl();
@@ -11692,21 +11848,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__0__Impl"
-    // InternalFSM.g:4028:1: rule__DetailCode__Group_1__0__Impl : ( ( rule__DetailCode__UsedAssignment_1_0 ) ) ;
+    // InternalFSM.g:4075:1: rule__DetailCode__Group_1__0__Impl : ( ( rule__DetailCode__UsedAssignment_1_0 ) ) ;
     public final void rule__DetailCode__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4032:1: ( ( ( rule__DetailCode__UsedAssignment_1_0 ) ) )
-            // InternalFSM.g:4033:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
+            // InternalFSM.g:4079:1: ( ( ( rule__DetailCode__UsedAssignment_1_0 ) ) )
+            // InternalFSM.g:4080:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
             {
-            // InternalFSM.g:4033:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
-            // InternalFSM.g:4034:1: ( rule__DetailCode__UsedAssignment_1_0 )
+            // InternalFSM.g:4080:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
+            // InternalFSM.g:4081:1: ( rule__DetailCode__UsedAssignment_1_0 )
             {
              before(grammarAccess.getDetailCodeAccess().getUsedAssignment_1_0()); 
-            // InternalFSM.g:4035:1: ( rule__DetailCode__UsedAssignment_1_0 )
-            // InternalFSM.g:4035:2: rule__DetailCode__UsedAssignment_1_0
+            // InternalFSM.g:4082:1: ( rule__DetailCode__UsedAssignment_1_0 )
+            // InternalFSM.g:4082:2: rule__DetailCode__UsedAssignment_1_0
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__UsedAssignment_1_0();
@@ -11739,14 +11895,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__1"
-    // InternalFSM.g:4045:1: rule__DetailCode__Group_1__1 : rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 ;
+    // InternalFSM.g:4092:1: rule__DetailCode__Group_1__1 : rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 ;
     public final void rule__DetailCode__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4049:1: ( rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 )
-            // InternalFSM.g:4050:2: rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2
+            // InternalFSM.g:4096:1: ( rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 )
+            // InternalFSM.g:4097:2: rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2
             {
             pushFollow(FOLLOW_14);
             rule__DetailCode__Group_1__1__Impl();
@@ -11777,33 +11933,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__1__Impl"
-    // InternalFSM.g:4057:1: rule__DetailCode__Group_1__1__Impl : ( ( rule__DetailCode__LinesAssignment_1_1 )* ) ;
+    // InternalFSM.g:4104:1: rule__DetailCode__Group_1__1__Impl : ( ( rule__DetailCode__LinesAssignment_1_1 )* ) ;
     public final void rule__DetailCode__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4061:1: ( ( ( rule__DetailCode__LinesAssignment_1_1 )* ) )
-            // InternalFSM.g:4062:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
+            // InternalFSM.g:4108:1: ( ( ( rule__DetailCode__LinesAssignment_1_1 )* ) )
+            // InternalFSM.g:4109:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
             {
-            // InternalFSM.g:4062:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
-            // InternalFSM.g:4063:1: ( rule__DetailCode__LinesAssignment_1_1 )*
+            // InternalFSM.g:4109:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
+            // InternalFSM.g:4110:1: ( rule__DetailCode__LinesAssignment_1_1 )*
             {
              before(grammarAccess.getDetailCodeAccess().getLinesAssignment_1_1()); 
-            // InternalFSM.g:4064:1: ( rule__DetailCode__LinesAssignment_1_1 )*
-            loop45:
+            // InternalFSM.g:4111:1: ( rule__DetailCode__LinesAssignment_1_1 )*
+            loop46:
             do {
-                int alt45=2;
-                int LA45_0 = input.LA(1);
+                int alt46=2;
+                int LA46_0 = input.LA(1);
 
-                if ( (LA45_0==RULE_STRING) ) {
-                    alt45=1;
+                if ( (LA46_0==RULE_STRING) ) {
+                    alt46=1;
                 }
 
 
-                switch (alt45) {
+                switch (alt46) {
             	case 1 :
-            	    // InternalFSM.g:4064:2: rule__DetailCode__LinesAssignment_1_1
+            	    // InternalFSM.g:4111:2: rule__DetailCode__LinesAssignment_1_1
             	    {
             	    pushFollow(FOLLOW_15);
             	    rule__DetailCode__LinesAssignment_1_1();
@@ -11815,7 +11971,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop45;
+            	    break loop46;
                 }
             } while (true);
 
@@ -11842,14 +11998,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__2"
-    // InternalFSM.g:4074:1: rule__DetailCode__Group_1__2 : rule__DetailCode__Group_1__2__Impl ;
+    // InternalFSM.g:4121:1: rule__DetailCode__Group_1__2 : rule__DetailCode__Group_1__2__Impl ;
     public final void rule__DetailCode__Group_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4078:1: ( rule__DetailCode__Group_1__2__Impl )
-            // InternalFSM.g:4079:2: rule__DetailCode__Group_1__2__Impl
+            // InternalFSM.g:4125:1: ( rule__DetailCode__Group_1__2__Impl )
+            // InternalFSM.g:4126:2: rule__DetailCode__Group_1__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_1__2__Impl();
@@ -11875,17 +12031,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__2__Impl"
-    // InternalFSM.g:4085:1: rule__DetailCode__Group_1__2__Impl : ( '}' ) ;
+    // InternalFSM.g:4132:1: rule__DetailCode__Group_1__2__Impl : ( '}' ) ;
     public final void rule__DetailCode__Group_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4089:1: ( ( '}' ) )
-            // InternalFSM.g:4090:1: ( '}' )
+            // InternalFSM.g:4136:1: ( ( '}' ) )
+            // InternalFSM.g:4137:1: ( '}' )
             {
-            // InternalFSM.g:4090:1: ( '}' )
-            // InternalFSM.g:4091:1: '}'
+            // InternalFSM.g:4137:1: ( '}' )
+            // InternalFSM.g:4138:1: '}'
             {
              before(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_1_2()); 
             match(input,30,FOLLOW_2); 
@@ -11912,14 +12068,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__0"
-    // InternalFSM.g:4110:1: rule__TransitionPoint__Group__0 : rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ;
+    // InternalFSM.g:4157:1: rule__TransitionPoint__Group__0 : rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ;
     public final void rule__TransitionPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4114:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 )
-            // InternalFSM.g:4115:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1
+            // InternalFSM.g:4161:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 )
+            // InternalFSM.g:4162:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1
             {
             pushFollow(FOLLOW_16);
             rule__TransitionPoint__Group__0__Impl();
@@ -11950,29 +12106,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__0__Impl"
-    // InternalFSM.g:4122:1: rule__TransitionPoint__Group__0__Impl : ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ;
+    // InternalFSM.g:4169:1: rule__TransitionPoint__Group__0__Impl : ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ;
     public final void rule__TransitionPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4126:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) )
-            // InternalFSM.g:4127:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
+            // InternalFSM.g:4173:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) )
+            // InternalFSM.g:4174:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
             {
-            // InternalFSM.g:4127:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
-            // InternalFSM.g:4128:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            // InternalFSM.g:4174:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
+            // InternalFSM.g:4175:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); 
-            // InternalFSM.g:4129:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
-            int alt46=2;
-            int LA46_0 = input.LA(1);
+            // InternalFSM.g:4176:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            int alt47=2;
+            int LA47_0 = input.LA(1);
 
-            if ( (LA46_0==70) ) {
-                alt46=1;
+            if ( (LA47_0==70) ) {
+                alt47=1;
             }
-            switch (alt46) {
+            switch (alt47) {
                 case 1 :
-                    // InternalFSM.g:4129:2: rule__TransitionPoint__HandlerAssignment_0
+                    // InternalFSM.g:4176:2: rule__TransitionPoint__HandlerAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TransitionPoint__HandlerAssignment_0();
@@ -12008,14 +12164,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__1"
-    // InternalFSM.g:4139:1: rule__TransitionPoint__Group__1 : rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ;
+    // InternalFSM.g:4186:1: rule__TransitionPoint__Group__1 : rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ;
     public final void rule__TransitionPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4143:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 )
-            // InternalFSM.g:4144:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2
+            // InternalFSM.g:4190:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 )
+            // InternalFSM.g:4191:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__TransitionPoint__Group__1__Impl();
@@ -12046,17 +12202,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__1__Impl"
-    // InternalFSM.g:4151:1: rule__TransitionPoint__Group__1__Impl : ( 'TransitionPoint' ) ;
+    // InternalFSM.g:4198:1: rule__TransitionPoint__Group__1__Impl : ( 'TransitionPoint' ) ;
     public final void rule__TransitionPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4155:1: ( ( 'TransitionPoint' ) )
-            // InternalFSM.g:4156:1: ( 'TransitionPoint' )
+            // InternalFSM.g:4202:1: ( ( 'TransitionPoint' ) )
+            // InternalFSM.g:4203:1: ( 'TransitionPoint' )
             {
-            // InternalFSM.g:4156:1: ( 'TransitionPoint' )
-            // InternalFSM.g:4157:1: 'TransitionPoint'
+            // InternalFSM.g:4203:1: ( 'TransitionPoint' )
+            // InternalFSM.g:4204:1: 'TransitionPoint'
             {
              before(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); 
             match(input,38,FOLLOW_2); 
@@ -12083,14 +12239,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__2"
-    // InternalFSM.g:4170:1: rule__TransitionPoint__Group__2 : rule__TransitionPoint__Group__2__Impl ;
+    // InternalFSM.g:4217:1: rule__TransitionPoint__Group__2 : rule__TransitionPoint__Group__2__Impl ;
     public final void rule__TransitionPoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4174:1: ( rule__TransitionPoint__Group__2__Impl )
-            // InternalFSM.g:4175:2: rule__TransitionPoint__Group__2__Impl
+            // InternalFSM.g:4221:1: ( rule__TransitionPoint__Group__2__Impl )
+            // InternalFSM.g:4222:2: rule__TransitionPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__Group__2__Impl();
@@ -12116,21 +12272,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__2__Impl"
-    // InternalFSM.g:4181:1: rule__TransitionPoint__Group__2__Impl : ( ( rule__TransitionPoint__NameAssignment_2 ) ) ;
+    // InternalFSM.g:4228:1: rule__TransitionPoint__Group__2__Impl : ( ( rule__TransitionPoint__NameAssignment_2 ) ) ;
     public final void rule__TransitionPoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4185:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) )
-            // InternalFSM.g:4186:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
+            // InternalFSM.g:4232:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) )
+            // InternalFSM.g:4233:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
             {
-            // InternalFSM.g:4186:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
-            // InternalFSM.g:4187:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalFSM.g:4233:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
+            // InternalFSM.g:4234:1: ( rule__TransitionPoint__NameAssignment_2 )
             {
              before(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); 
-            // InternalFSM.g:4188:1: ( rule__TransitionPoint__NameAssignment_2 )
-            // InternalFSM.g:4188:2: rule__TransitionPoint__NameAssignment_2
+            // InternalFSM.g:4235:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalFSM.g:4235:2: rule__TransitionPoint__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__NameAssignment_2();
@@ -12163,14 +12319,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__0"
-    // InternalFSM.g:4204:1: rule__EntryPoint__Group__0 : rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ;
+    // InternalFSM.g:4251:1: rule__EntryPoint__Group__0 : rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ;
     public final void rule__EntryPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4208:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 )
-            // InternalFSM.g:4209:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1
+            // InternalFSM.g:4255:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 )
+            // InternalFSM.g:4256:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__EntryPoint__Group__0__Impl();
@@ -12201,17 +12357,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__0__Impl"
-    // InternalFSM.g:4216:1: rule__EntryPoint__Group__0__Impl : ( 'EntryPoint' ) ;
+    // InternalFSM.g:4263:1: rule__EntryPoint__Group__0__Impl : ( 'EntryPoint' ) ;
     public final void rule__EntryPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4220:1: ( ( 'EntryPoint' ) )
-            // InternalFSM.g:4221:1: ( 'EntryPoint' )
+            // InternalFSM.g:4267:1: ( ( 'EntryPoint' ) )
+            // InternalFSM.g:4268:1: ( 'EntryPoint' )
             {
-            // InternalFSM.g:4221:1: ( 'EntryPoint' )
-            // InternalFSM.g:4222:1: 'EntryPoint'
+            // InternalFSM.g:4268:1: ( 'EntryPoint' )
+            // InternalFSM.g:4269:1: 'EntryPoint'
             {
              before(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); 
             match(input,39,FOLLOW_2); 
@@ -12238,14 +12394,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__1"
-    // InternalFSM.g:4235:1: rule__EntryPoint__Group__1 : rule__EntryPoint__Group__1__Impl ;
+    // InternalFSM.g:4282:1: rule__EntryPoint__Group__1 : rule__EntryPoint__Group__1__Impl ;
     public final void rule__EntryPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4239:1: ( rule__EntryPoint__Group__1__Impl )
-            // InternalFSM.g:4240:2: rule__EntryPoint__Group__1__Impl
+            // InternalFSM.g:4286:1: ( rule__EntryPoint__Group__1__Impl )
+            // InternalFSM.g:4287:2: rule__EntryPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__Group__1__Impl();
@@ -12271,21 +12427,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__1__Impl"
-    // InternalFSM.g:4246:1: rule__EntryPoint__Group__1__Impl : ( ( rule__EntryPoint__NameAssignment_1 ) ) ;
+    // InternalFSM.g:4293:1: rule__EntryPoint__Group__1__Impl : ( ( rule__EntryPoint__NameAssignment_1 ) ) ;
     public final void rule__EntryPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4250:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) )
-            // InternalFSM.g:4251:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
+            // InternalFSM.g:4297:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) )
+            // InternalFSM.g:4298:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
             {
-            // InternalFSM.g:4251:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
-            // InternalFSM.g:4252:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalFSM.g:4298:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
+            // InternalFSM.g:4299:1: ( rule__EntryPoint__NameAssignment_1 )
             {
              before(grammarAccess.getEntryPointAccess().getNameAssignment_1()); 
-            // InternalFSM.g:4253:1: ( rule__EntryPoint__NameAssignment_1 )
-            // InternalFSM.g:4253:2: rule__EntryPoint__NameAssignment_1
+            // InternalFSM.g:4300:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalFSM.g:4300:2: rule__EntryPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__NameAssignment_1();
@@ -12318,14 +12474,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__0"
-    // InternalFSM.g:4267:1: rule__ExitPoint__Group__0 : rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ;
+    // InternalFSM.g:4314:1: rule__ExitPoint__Group__0 : rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ;
     public final void rule__ExitPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4271:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 )
-            // InternalFSM.g:4272:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1
+            // InternalFSM.g:4318:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 )
+            // InternalFSM.g:4319:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__ExitPoint__Group__0__Impl();
@@ -12356,17 +12512,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__0__Impl"
-    // InternalFSM.g:4279:1: rule__ExitPoint__Group__0__Impl : ( 'ExitPoint' ) ;
+    // InternalFSM.g:4326:1: rule__ExitPoint__Group__0__Impl : ( 'ExitPoint' ) ;
     public final void rule__ExitPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4283:1: ( ( 'ExitPoint' ) )
-            // InternalFSM.g:4284:1: ( 'ExitPoint' )
+            // InternalFSM.g:4330:1: ( ( 'ExitPoint' ) )
+            // InternalFSM.g:4331:1: ( 'ExitPoint' )
             {
-            // InternalFSM.g:4284:1: ( 'ExitPoint' )
-            // InternalFSM.g:4285:1: 'ExitPoint'
+            // InternalFSM.g:4331:1: ( 'ExitPoint' )
+            // InternalFSM.g:4332:1: 'ExitPoint'
             {
              before(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); 
             match(input,40,FOLLOW_2); 
@@ -12393,14 +12549,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__1"
-    // InternalFSM.g:4298:1: rule__ExitPoint__Group__1 : rule__ExitPoint__Group__1__Impl ;
+    // InternalFSM.g:4345:1: rule__ExitPoint__Group__1 : rule__ExitPoint__Group__1__Impl ;
     public final void rule__ExitPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4302:1: ( rule__ExitPoint__Group__1__Impl )
-            // InternalFSM.g:4303:2: rule__ExitPoint__Group__1__Impl
+            // InternalFSM.g:4349:1: ( rule__ExitPoint__Group__1__Impl )
+            // InternalFSM.g:4350:2: rule__ExitPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__Group__1__Impl();
@@ -12426,21 +12582,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__1__Impl"
-    // InternalFSM.g:4309:1: rule__ExitPoint__Group__1__Impl : ( ( rule__ExitPoint__NameAssignment_1 ) ) ;
+    // InternalFSM.g:4356:1: rule__ExitPoint__Group__1__Impl : ( ( rule__ExitPoint__NameAssignment_1 ) ) ;
     public final void rule__ExitPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4313:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) )
-            // InternalFSM.g:4314:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
+            // InternalFSM.g:4360:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) )
+            // InternalFSM.g:4361:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
             {
-            // InternalFSM.g:4314:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
-            // InternalFSM.g:4315:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalFSM.g:4361:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
+            // InternalFSM.g:4362:1: ( rule__ExitPoint__NameAssignment_1 )
             {
              before(grammarAccess.getExitPointAccess().getNameAssignment_1()); 
-            // InternalFSM.g:4316:1: ( rule__ExitPoint__NameAssignment_1 )
-            // InternalFSM.g:4316:2: rule__ExitPoint__NameAssignment_1
+            // InternalFSM.g:4363:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalFSM.g:4363:2: rule__ExitPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__NameAssignment_1();
@@ -12473,14 +12629,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__0"
-    // InternalFSM.g:4330:1: rule__ChoicePoint__Group__0 : rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ;
+    // InternalFSM.g:4377:1: rule__ChoicePoint__Group__0 : rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ;
     public final void rule__ChoicePoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4334:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 )
-            // InternalFSM.g:4335:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1
+            // InternalFSM.g:4381:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 )
+            // InternalFSM.g:4382:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__ChoicePoint__Group__0__Impl();
@@ -12511,17 +12667,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__0__Impl"
-    // InternalFSM.g:4342:1: rule__ChoicePoint__Group__0__Impl : ( 'ChoicePoint' ) ;
+    // InternalFSM.g:4389:1: rule__ChoicePoint__Group__0__Impl : ( 'ChoicePoint' ) ;
     public final void rule__ChoicePoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4346:1: ( ( 'ChoicePoint' ) )
-            // InternalFSM.g:4347:1: ( 'ChoicePoint' )
+            // InternalFSM.g:4393:1: ( ( 'ChoicePoint' ) )
+            // InternalFSM.g:4394:1: ( 'ChoicePoint' )
             {
-            // InternalFSM.g:4347:1: ( 'ChoicePoint' )
-            // InternalFSM.g:4348:1: 'ChoicePoint'
+            // InternalFSM.g:4394:1: ( 'ChoicePoint' )
+            // InternalFSM.g:4395:1: 'ChoicePoint'
             {
              before(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); 
             match(input,41,FOLLOW_2); 
@@ -12548,14 +12704,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__1"
-    // InternalFSM.g:4361:1: rule__ChoicePoint__Group__1 : rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ;
+    // InternalFSM.g:4408:1: rule__ChoicePoint__Group__1 : rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ;
     public final void rule__ChoicePoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4365:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 )
-            // InternalFSM.g:4366:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2
+            // InternalFSM.g:4412:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 )
+            // InternalFSM.g:4413:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2
             {
             pushFollow(FOLLOW_17);
             rule__ChoicePoint__Group__1__Impl();
@@ -12586,21 +12742,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__1__Impl"
-    // InternalFSM.g:4373:1: rule__ChoicePoint__Group__1__Impl : ( ( rule__ChoicePoint__NameAssignment_1 ) ) ;
+    // InternalFSM.g:4420:1: rule__ChoicePoint__Group__1__Impl : ( ( rule__ChoicePoint__NameAssignment_1 ) ) ;
     public final void rule__ChoicePoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4377:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) )
-            // InternalFSM.g:4378:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
+            // InternalFSM.g:4424:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) )
+            // InternalFSM.g:4425:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
             {
-            // InternalFSM.g:4378:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
-            // InternalFSM.g:4379:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalFSM.g:4425:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
+            // InternalFSM.g:4426:1: ( rule__ChoicePoint__NameAssignment_1 )
             {
              before(grammarAccess.getChoicePointAccess().getNameAssignment_1()); 
-            // InternalFSM.g:4380:1: ( rule__ChoicePoint__NameAssignment_1 )
-            // InternalFSM.g:4380:2: rule__ChoicePoint__NameAssignment_1
+            // InternalFSM.g:4427:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalFSM.g:4427:2: rule__ChoicePoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__NameAssignment_1();
@@ -12633,14 +12789,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__2"
-    // InternalFSM.g:4390:1: rule__ChoicePoint__Group__2 : rule__ChoicePoint__Group__2__Impl ;
+    // InternalFSM.g:4437:1: rule__ChoicePoint__Group__2 : rule__ChoicePoint__Group__2__Impl ;
     public final void rule__ChoicePoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4394:1: ( rule__ChoicePoint__Group__2__Impl )
-            // InternalFSM.g:4395:2: rule__ChoicePoint__Group__2__Impl
+            // InternalFSM.g:4441:1: ( rule__ChoicePoint__Group__2__Impl )
+            // InternalFSM.g:4442:2: rule__ChoicePoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__Group__2__Impl();
@@ -12666,29 +12822,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__2__Impl"
-    // InternalFSM.g:4401:1: rule__ChoicePoint__Group__2__Impl : ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ;
+    // InternalFSM.g:4448:1: rule__ChoicePoint__Group__2__Impl : ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ;
     public final void rule__ChoicePoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4405:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) )
-            // InternalFSM.g:4406:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
+            // InternalFSM.g:4452:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) )
+            // InternalFSM.g:4453:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
             {
-            // InternalFSM.g:4406:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
-            // InternalFSM.g:4407:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            // InternalFSM.g:4453:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
+            // InternalFSM.g:4454:1: ( rule__ChoicePoint__DocuAssignment_2 )?
             {
              before(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); 
-            // InternalFSM.g:4408:1: ( rule__ChoicePoint__DocuAssignment_2 )?
-            int alt47=2;
-            int LA47_0 = input.LA(1);
+            // InternalFSM.g:4455:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            int alt48=2;
+            int LA48_0 = input.LA(1);
 
-            if ( (LA47_0==66) ) {
-                alt47=1;
+            if ( (LA48_0==66) ) {
+                alt48=1;
             }
-            switch (alt47) {
+            switch (alt48) {
                 case 1 :
-                    // InternalFSM.g:4408:2: rule__ChoicePoint__DocuAssignment_2
+                    // InternalFSM.g:4455:2: rule__ChoicePoint__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__ChoicePoint__DocuAssignment_2();
@@ -12724,14 +12880,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__0"
-    // InternalFSM.g:4424:1: rule__InitialTransition__Group__0 : rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ;
+    // InternalFSM.g:4471:1: rule__InitialTransition__Group__0 : rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ;
     public final void rule__InitialTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4428:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 )
-            // InternalFSM.g:4429:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1
+            // InternalFSM.g:4475:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 )
+            // InternalFSM.g:4476:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1
             {
             pushFollow(FOLLOW_18);
             rule__InitialTransition__Group__0__Impl();
@@ -12762,17 +12918,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__0__Impl"
-    // InternalFSM.g:4436:1: rule__InitialTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalFSM.g:4483:1: rule__InitialTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__InitialTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4440:1: ( ( 'Transition' ) )
-            // InternalFSM.g:4441:1: ( 'Transition' )
+            // InternalFSM.g:4487:1: ( ( 'Transition' ) )
+            // InternalFSM.g:4488:1: ( 'Transition' )
             {
-            // InternalFSM.g:4441:1: ( 'Transition' )
-            // InternalFSM.g:4442:1: 'Transition'
+            // InternalFSM.g:4488:1: ( 'Transition' )
+            // InternalFSM.g:4489:1: 'Transition'
             {
              before(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); 
             match(input,42,FOLLOW_2); 
@@ -12799,14 +12955,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__1"
-    // InternalFSM.g:4455:1: rule__InitialTransition__Group__1 : rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ;
+    // InternalFSM.g:4502:1: rule__InitialTransition__Group__1 : rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ;
     public final void rule__InitialTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4459:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 )
-            // InternalFSM.g:4460:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2
+            // InternalFSM.g:4506:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 )
+            // InternalFSM.g:4507:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2
             {
             pushFollow(FOLLOW_18);
             rule__InitialTransition__Group__1__Impl();
@@ -12837,29 +12993,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__1__Impl"
-    // InternalFSM.g:4467:1: rule__InitialTransition__Group__1__Impl : ( ( rule__InitialTransition__NameAssignment_1 )? ) ;
+    // InternalFSM.g:4514:1: rule__InitialTransition__Group__1__Impl : ( ( rule__InitialTransition__NameAssignment_1 )? ) ;
     public final void rule__InitialTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4471:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) )
-            // InternalFSM.g:4472:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
+            // InternalFSM.g:4518:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) )
+            // InternalFSM.g:4519:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
             {
-            // InternalFSM.g:4472:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
-            // InternalFSM.g:4473:1: ( rule__InitialTransition__NameAssignment_1 )?
+            // InternalFSM.g:4519:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
+            // InternalFSM.g:4520:1: ( rule__InitialTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); 
-            // InternalFSM.g:4474:1: ( rule__InitialTransition__NameAssignment_1 )?
-            int alt48=2;
-            int LA48_0 = input.LA(1);
+            // InternalFSM.g:4521:1: ( rule__InitialTransition__NameAssignment_1 )?
+            int alt49=2;
+            int LA49_0 = input.LA(1);
 
-            if ( (LA48_0==RULE_ID) ) {
-                alt48=1;
+            if ( (LA49_0==RULE_ID) ) {
+                alt49=1;
             }
-            switch (alt48) {
+            switch (alt49) {
                 case 1 :
-                    // InternalFSM.g:4474:2: rule__InitialTransition__NameAssignment_1
+                    // InternalFSM.g:4521:2: rule__InitialTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__NameAssignment_1();
@@ -12895,14 +13051,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__2"
-    // InternalFSM.g:4484:1: rule__InitialTransition__Group__2 : rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ;
+    // InternalFSM.g:4531:1: rule__InitialTransition__Group__2 : rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ;
     public final void rule__InitialTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4488:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 )
-            // InternalFSM.g:4489:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3
+            // InternalFSM.g:4535:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 )
+            // InternalFSM.g:4536:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3
             {
             pushFollow(FOLLOW_19);
             rule__InitialTransition__Group__2__Impl();
@@ -12933,17 +13089,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__2__Impl"
-    // InternalFSM.g:4496:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ;
+    // InternalFSM.g:4543:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__InitialTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4500:1: ( ( ':' ) )
-            // InternalFSM.g:4501:1: ( ':' )
+            // InternalFSM.g:4547:1: ( ( ':' ) )
+            // InternalFSM.g:4548:1: ( ':' )
             {
-            // InternalFSM.g:4501:1: ( ':' )
-            // InternalFSM.g:4502:1: ':'
+            // InternalFSM.g:4548:1: ( ':' )
+            // InternalFSM.g:4549:1: ':'
             {
              before(grammarAccess.getInitialTransitionAccess().getColonKeyword_2()); 
             match(input,43,FOLLOW_2); 
@@ -12970,14 +13126,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__3"
-    // InternalFSM.g:4515:1: rule__InitialTransition__Group__3 : rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ;
+    // InternalFSM.g:4562:1: rule__InitialTransition__Group__3 : rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ;
     public final void rule__InitialTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4519:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 )
-            // InternalFSM.g:4520:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4
+            // InternalFSM.g:4566:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 )
+            // InternalFSM.g:4567:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4
             {
             pushFollow(FOLLOW_20);
             rule__InitialTransition__Group__3__Impl();
@@ -13008,17 +13164,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__3__Impl"
-    // InternalFSM.g:4527:1: rule__InitialTransition__Group__3__Impl : ( 'initial' ) ;
+    // InternalFSM.g:4574:1: rule__InitialTransition__Group__3__Impl : ( 'initial' ) ;
     public final void rule__InitialTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4531:1: ( ( 'initial' ) )
-            // InternalFSM.g:4532:1: ( 'initial' )
+            // InternalFSM.g:4578:1: ( ( 'initial' ) )
+            // InternalFSM.g:4579:1: ( 'initial' )
             {
-            // InternalFSM.g:4532:1: ( 'initial' )
-            // InternalFSM.g:4533:1: 'initial'
+            // InternalFSM.g:4579:1: ( 'initial' )
+            // InternalFSM.g:4580:1: 'initial'
             {
              before(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -13045,14 +13201,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__4"
-    // InternalFSM.g:4546:1: rule__InitialTransition__Group__4 : rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ;
+    // InternalFSM.g:4593:1: rule__InitialTransition__Group__4 : rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ;
     public final void rule__InitialTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4550:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 )
-            // InternalFSM.g:4551:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5
+            // InternalFSM.g:4597:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 )
+            // InternalFSM.g:4598:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5
             {
             pushFollow(FOLLOW_21);
             rule__InitialTransition__Group__4__Impl();
@@ -13083,17 +13239,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__4__Impl"
-    // InternalFSM.g:4558:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ;
+    // InternalFSM.g:4605:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__InitialTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4562:1: ( ( '->' ) )
-            // InternalFSM.g:4563:1: ( '->' )
+            // InternalFSM.g:4609:1: ( ( '->' ) )
+            // InternalFSM.g:4610:1: ( '->' )
             {
-            // InternalFSM.g:4563:1: ( '->' )
-            // InternalFSM.g:4564:1: '->'
+            // InternalFSM.g:4610:1: ( '->' )
+            // InternalFSM.g:4611:1: '->'
             {
              before(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -13120,14 +13276,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__5"
-    // InternalFSM.g:4577:1: rule__InitialTransition__Group__5 : rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ;
+    // InternalFSM.g:4624:1: rule__InitialTransition__Group__5 : rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ;
     public final void rule__InitialTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4581:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 )
-            // InternalFSM.g:4582:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6
+            // InternalFSM.g:4628:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 )
+            // InternalFSM.g:4629:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6
             {
             pushFollow(FOLLOW_10);
             rule__InitialTransition__Group__5__Impl();
@@ -13158,21 +13314,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__5__Impl"
-    // InternalFSM.g:4589:1: rule__InitialTransition__Group__5__Impl : ( ( rule__InitialTransition__ToAssignment_5 ) ) ;
+    // InternalFSM.g:4636:1: rule__InitialTransition__Group__5__Impl : ( ( rule__InitialTransition__ToAssignment_5 ) ) ;
     public final void rule__InitialTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4593:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) )
-            // InternalFSM.g:4594:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
+            // InternalFSM.g:4640:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) )
+            // InternalFSM.g:4641:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
             {
-            // InternalFSM.g:4594:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
-            // InternalFSM.g:4595:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalFSM.g:4641:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
+            // InternalFSM.g:4642:1: ( rule__InitialTransition__ToAssignment_5 )
             {
              before(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); 
-            // InternalFSM.g:4596:1: ( rule__InitialTransition__ToAssignment_5 )
-            // InternalFSM.g:4596:2: rule__InitialTransition__ToAssignment_5
+            // InternalFSM.g:4643:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalFSM.g:4643:2: rule__InitialTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ToAssignment_5();
@@ -13205,14 +13361,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__6"
-    // InternalFSM.g:4606:1: rule__InitialTransition__Group__6 : rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ;
+    // InternalFSM.g:4653:1: rule__InitialTransition__Group__6 : rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ;
     public final void rule__InitialTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4610:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 )
-            // InternalFSM.g:4611:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7
+            // InternalFSM.g:4657:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 )
+            // InternalFSM.g:4658:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7
             {
             pushFollow(FOLLOW_10);
             rule__InitialTransition__Group__6__Impl();
@@ -13243,29 +13399,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__6__Impl"
-    // InternalFSM.g:4618:1: rule__InitialTransition__Group__6__Impl : ( ( rule__InitialTransition__DocuAssignment_6 )? ) ;
+    // InternalFSM.g:4665:1: rule__InitialTransition__Group__6__Impl : ( ( rule__InitialTransition__DocuAssignment_6 )? ) ;
     public final void rule__InitialTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4622:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) )
-            // InternalFSM.g:4623:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:4669:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) )
+            // InternalFSM.g:4670:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
             {
-            // InternalFSM.g:4623:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
-            // InternalFSM.g:4624:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            // InternalFSM.g:4670:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:4671:1: ( rule__InitialTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); 
-            // InternalFSM.g:4625:1: ( rule__InitialTransition__DocuAssignment_6 )?
-            int alt49=2;
-            int LA49_0 = input.LA(1);
+            // InternalFSM.g:4672:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            int alt50=2;
+            int LA50_0 = input.LA(1);
 
-            if ( (LA49_0==66) ) {
-                alt49=1;
+            if ( (LA50_0==66) ) {
+                alt50=1;
             }
-            switch (alt49) {
+            switch (alt50) {
                 case 1 :
-                    // InternalFSM.g:4625:2: rule__InitialTransition__DocuAssignment_6
+                    // InternalFSM.g:4672:2: rule__InitialTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__DocuAssignment_6();
@@ -13301,14 +13457,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__7"
-    // InternalFSM.g:4635:1: rule__InitialTransition__Group__7 : rule__InitialTransition__Group__7__Impl ;
+    // InternalFSM.g:4682:1: rule__InitialTransition__Group__7 : rule__InitialTransition__Group__7__Impl ;
     public final void rule__InitialTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4639:1: ( rule__InitialTransition__Group__7__Impl )
-            // InternalFSM.g:4640:2: rule__InitialTransition__Group__7__Impl
+            // InternalFSM.g:4686:1: ( rule__InitialTransition__Group__7__Impl )
+            // InternalFSM.g:4687:2: rule__InitialTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__7__Impl();
@@ -13334,29 +13490,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__7__Impl"
-    // InternalFSM.g:4646:1: rule__InitialTransition__Group__7__Impl : ( ( rule__InitialTransition__Group_7__0 )? ) ;
+    // InternalFSM.g:4693:1: rule__InitialTransition__Group__7__Impl : ( ( rule__InitialTransition__Group_7__0 )? ) ;
     public final void rule__InitialTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4650:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) )
-            // InternalFSM.g:4651:1: ( ( rule__InitialTransition__Group_7__0 )? )
+            // InternalFSM.g:4697:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) )
+            // InternalFSM.g:4698:1: ( ( rule__InitialTransition__Group_7__0 )? )
             {
-            // InternalFSM.g:4651:1: ( ( rule__InitialTransition__Group_7__0 )? )
-            // InternalFSM.g:4652:1: ( rule__InitialTransition__Group_7__0 )?
+            // InternalFSM.g:4698:1: ( ( rule__InitialTransition__Group_7__0 )? )
+            // InternalFSM.g:4699:1: ( rule__InitialTransition__Group_7__0 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup_7()); 
-            // InternalFSM.g:4653:1: ( rule__InitialTransition__Group_7__0 )?
-            int alt50=2;
-            int LA50_0 = input.LA(1);
+            // InternalFSM.g:4700:1: ( rule__InitialTransition__Group_7__0 )?
+            int alt51=2;
+            int LA51_0 = input.LA(1);
 
-            if ( (LA50_0==29) ) {
-                alt50=1;
+            if ( (LA51_0==29) ) {
+                alt51=1;
             }
-            switch (alt50) {
+            switch (alt51) {
                 case 1 :
-                    // InternalFSM.g:4653:2: rule__InitialTransition__Group_7__0
+                    // InternalFSM.g:4700:2: rule__InitialTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7__0();
@@ -13392,14 +13548,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__0"
-    // InternalFSM.g:4679:1: rule__InitialTransition__Group_7__0 : rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ;
+    // InternalFSM.g:4726:1: rule__InitialTransition__Group_7__0 : rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ;
     public final void rule__InitialTransition__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4683:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 )
-            // InternalFSM.g:4684:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1
+            // InternalFSM.g:4730:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 )
+            // InternalFSM.g:4731:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1
             {
             pushFollow(FOLLOW_22);
             rule__InitialTransition__Group_7__0__Impl();
@@ -13430,17 +13586,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__0__Impl"
-    // InternalFSM.g:4691:1: rule__InitialTransition__Group_7__0__Impl : ( '{' ) ;
+    // InternalFSM.g:4738:1: rule__InitialTransition__Group_7__0__Impl : ( '{' ) ;
     public final void rule__InitialTransition__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4695:1: ( ( '{' ) )
-            // InternalFSM.g:4696:1: ( '{' )
+            // InternalFSM.g:4742:1: ( ( '{' ) )
+            // InternalFSM.g:4743:1: ( '{' )
             {
-            // InternalFSM.g:4696:1: ( '{' )
-            // InternalFSM.g:4697:1: '{'
+            // InternalFSM.g:4743:1: ( '{' )
+            // InternalFSM.g:4744:1: '{'
             {
              before(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,29,FOLLOW_2); 
@@ -13467,14 +13623,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__1"
-    // InternalFSM.g:4710:1: rule__InitialTransition__Group_7__1 : rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ;
+    // InternalFSM.g:4757:1: rule__InitialTransition__Group_7__1 : rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ;
     public final void rule__InitialTransition__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4714:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 )
-            // InternalFSM.g:4715:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2
+            // InternalFSM.g:4761:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 )
+            // InternalFSM.g:4762:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2
             {
             pushFollow(FOLLOW_22);
             rule__InitialTransition__Group_7__1__Impl();
@@ -13505,29 +13661,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__1__Impl"
-    // InternalFSM.g:4722:1: rule__InitialTransition__Group_7__1__Impl : ( ( rule__InitialTransition__Group_7_1__0 )? ) ;
+    // InternalFSM.g:4769:1: rule__InitialTransition__Group_7__1__Impl : ( ( rule__InitialTransition__Group_7_1__0 )? ) ;
     public final void rule__InitialTransition__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4726:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) )
-            // InternalFSM.g:4727:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
+            // InternalFSM.g:4773:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) )
+            // InternalFSM.g:4774:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
             {
-            // InternalFSM.g:4727:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
-            // InternalFSM.g:4728:1: ( rule__InitialTransition__Group_7_1__0 )?
+            // InternalFSM.g:4774:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
+            // InternalFSM.g:4775:1: ( rule__InitialTransition__Group_7_1__0 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); 
-            // InternalFSM.g:4729:1: ( rule__InitialTransition__Group_7_1__0 )?
-            int alt51=2;
-            int LA51_0 = input.LA(1);
+            // InternalFSM.g:4776:1: ( rule__InitialTransition__Group_7_1__0 )?
+            int alt52=2;
+            int LA52_0 = input.LA(1);
 
-            if ( (LA51_0==46) ) {
-                alt51=1;
+            if ( (LA52_0==46) ) {
+                alt52=1;
             }
-            switch (alt51) {
+            switch (alt52) {
                 case 1 :
-                    // InternalFSM.g:4729:2: rule__InitialTransition__Group_7_1__0
+                    // InternalFSM.g:4776:2: rule__InitialTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7_1__0();
@@ -13563,14 +13719,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__2"
-    // InternalFSM.g:4739:1: rule__InitialTransition__Group_7__2 : rule__InitialTransition__Group_7__2__Impl ;
+    // InternalFSM.g:4786:1: rule__InitialTransition__Group_7__2 : rule__InitialTransition__Group_7__2__Impl ;
     public final void rule__InitialTransition__Group_7__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4743:1: ( rule__InitialTransition__Group_7__2__Impl )
-            // InternalFSM.g:4744:2: rule__InitialTransition__Group_7__2__Impl
+            // InternalFSM.g:4790:1: ( rule__InitialTransition__Group_7__2__Impl )
+            // InternalFSM.g:4791:2: rule__InitialTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7__2__Impl();
@@ -13596,17 +13752,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__2__Impl"
-    // InternalFSM.g:4750:1: rule__InitialTransition__Group_7__2__Impl : ( '}' ) ;
+    // InternalFSM.g:4797:1: rule__InitialTransition__Group_7__2__Impl : ( '}' ) ;
     public final void rule__InitialTransition__Group_7__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4754:1: ( ( '}' ) )
-            // InternalFSM.g:4755:1: ( '}' )
+            // InternalFSM.g:4801:1: ( ( '}' ) )
+            // InternalFSM.g:4802:1: ( '}' )
             {
-            // InternalFSM.g:4755:1: ( '}' )
-            // InternalFSM.g:4756:1: '}'
+            // InternalFSM.g:4802:1: ( '}' )
+            // InternalFSM.g:4803:1: '}'
             {
              before(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,30,FOLLOW_2); 
@@ -13633,14 +13789,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__0"
-    // InternalFSM.g:4775:1: rule__InitialTransition__Group_7_1__0 : rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ;
+    // InternalFSM.g:4822:1: rule__InitialTransition__Group_7_1__0 : rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ;
     public final void rule__InitialTransition__Group_7_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4779:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 )
-            // InternalFSM.g:4780:2: rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1
+            // InternalFSM.g:4826:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 )
+            // InternalFSM.g:4827:2: rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1
             {
             pushFollow(FOLLOW_12);
             rule__InitialTransition__Group_7_1__0__Impl();
@@ -13671,17 +13827,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__0__Impl"
-    // InternalFSM.g:4787:1: rule__InitialTransition__Group_7_1__0__Impl : ( 'action' ) ;
+    // InternalFSM.g:4834:1: rule__InitialTransition__Group_7_1__0__Impl : ( 'action' ) ;
     public final void rule__InitialTransition__Group_7_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4791:1: ( ( 'action' ) )
-            // InternalFSM.g:4792:1: ( 'action' )
+            // InternalFSM.g:4838:1: ( ( 'action' ) )
+            // InternalFSM.g:4839:1: ( 'action' )
             {
-            // InternalFSM.g:4792:1: ( 'action' )
-            // InternalFSM.g:4793:1: 'action'
+            // InternalFSM.g:4839:1: ( 'action' )
+            // InternalFSM.g:4840:1: 'action'
             {
              before(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,46,FOLLOW_2); 
@@ -13708,14 +13864,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__1"
-    // InternalFSM.g:4806:1: rule__InitialTransition__Group_7_1__1 : rule__InitialTransition__Group_7_1__1__Impl ;
+    // InternalFSM.g:4853:1: rule__InitialTransition__Group_7_1__1 : rule__InitialTransition__Group_7_1__1__Impl ;
     public final void rule__InitialTransition__Group_7_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4810:1: ( rule__InitialTransition__Group_7_1__1__Impl )
-            // InternalFSM.g:4811:2: rule__InitialTransition__Group_7_1__1__Impl
+            // InternalFSM.g:4857:1: ( rule__InitialTransition__Group_7_1__1__Impl )
+            // InternalFSM.g:4858:2: rule__InitialTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7_1__1__Impl();
@@ -13741,21 +13897,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__1__Impl"
-    // InternalFSM.g:4817:1: rule__InitialTransition__Group_7_1__1__Impl : ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ;
+    // InternalFSM.g:4864:1: rule__InitialTransition__Group_7_1__1__Impl : ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ;
     public final void rule__InitialTransition__Group_7_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4821:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) )
-            // InternalFSM.g:4822:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
+            // InternalFSM.g:4868:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalFSM.g:4869:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
             {
-            // InternalFSM.g:4822:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
-            // InternalFSM.g:4823:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
+            // InternalFSM.g:4869:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
+            // InternalFSM.g:4870:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
             {
              before(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); 
-            // InternalFSM.g:4824:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
-            // InternalFSM.g:4824:2: rule__InitialTransition__ActionAssignment_7_1_1
+            // InternalFSM.g:4871:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
+            // InternalFSM.g:4871:2: rule__InitialTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ActionAssignment_7_1_1();
@@ -13788,14 +13944,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__0"
-    // InternalFSM.g:4838:1: rule__ContinuationTransition__Group__0 : rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ;
+    // InternalFSM.g:4885:1: rule__ContinuationTransition__Group__0 : rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ;
     public final void rule__ContinuationTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4842:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 )
-            // InternalFSM.g:4843:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1
+            // InternalFSM.g:4889:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 )
+            // InternalFSM.g:4890:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1
             {
             pushFollow(FOLLOW_18);
             rule__ContinuationTransition__Group__0__Impl();
@@ -13826,17 +13982,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__0__Impl"
-    // InternalFSM.g:4850:1: rule__ContinuationTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalFSM.g:4897:1: rule__ContinuationTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__ContinuationTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4854:1: ( ( 'Transition' ) )
-            // InternalFSM.g:4855:1: ( 'Transition' )
+            // InternalFSM.g:4901:1: ( ( 'Transition' ) )
+            // InternalFSM.g:4902:1: ( 'Transition' )
             {
-            // InternalFSM.g:4855:1: ( 'Transition' )
-            // InternalFSM.g:4856:1: 'Transition'
+            // InternalFSM.g:4902:1: ( 'Transition' )
+            // InternalFSM.g:4903:1: 'Transition'
             {
              before(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); 
             match(input,42,FOLLOW_2); 
@@ -13863,14 +14019,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__1"
-    // InternalFSM.g:4869:1: rule__ContinuationTransition__Group__1 : rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ;
+    // InternalFSM.g:4916:1: rule__ContinuationTransition__Group__1 : rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ;
     public final void rule__ContinuationTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4873:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 )
-            // InternalFSM.g:4874:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2
+            // InternalFSM.g:4920:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 )
+            // InternalFSM.g:4921:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2
             {
             pushFollow(FOLLOW_18);
             rule__ContinuationTransition__Group__1__Impl();
@@ -13901,29 +14057,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__1__Impl"
-    // InternalFSM.g:4881:1: rule__ContinuationTransition__Group__1__Impl : ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ;
+    // InternalFSM.g:4928:1: rule__ContinuationTransition__Group__1__Impl : ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ;
     public final void rule__ContinuationTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4885:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) )
-            // InternalFSM.g:4886:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
+            // InternalFSM.g:4932:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) )
+            // InternalFSM.g:4933:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
             {
-            // InternalFSM.g:4886:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
-            // InternalFSM.g:4887:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            // InternalFSM.g:4933:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
+            // InternalFSM.g:4934:1: ( rule__ContinuationTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); 
-            // InternalFSM.g:4888:1: ( rule__ContinuationTransition__NameAssignment_1 )?
-            int alt52=2;
-            int LA52_0 = input.LA(1);
+            // InternalFSM.g:4935:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            int alt53=2;
+            int LA53_0 = input.LA(1);
 
-            if ( (LA52_0==RULE_ID) ) {
-                alt52=1;
+            if ( (LA53_0==RULE_ID) ) {
+                alt53=1;
             }
-            switch (alt52) {
+            switch (alt53) {
                 case 1 :
-                    // InternalFSM.g:4888:2: rule__ContinuationTransition__NameAssignment_1
+                    // InternalFSM.g:4935:2: rule__ContinuationTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__NameAssignment_1();
@@ -13959,14 +14115,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__2"
-    // InternalFSM.g:4898:1: rule__ContinuationTransition__Group__2 : rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ;
+    // InternalFSM.g:4945:1: rule__ContinuationTransition__Group__2 : rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ;
     public final void rule__ContinuationTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4902:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 )
-            // InternalFSM.g:4903:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3
+            // InternalFSM.g:4949:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 )
+            // InternalFSM.g:4950:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3
             {
             pushFollow(FOLLOW_21);
             rule__ContinuationTransition__Group__2__Impl();
@@ -13997,17 +14153,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__2__Impl"
-    // InternalFSM.g:4910:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ;
+    // InternalFSM.g:4957:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__ContinuationTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4914:1: ( ( ':' ) )
-            // InternalFSM.g:4915:1: ( ':' )
+            // InternalFSM.g:4961:1: ( ( ':' ) )
+            // InternalFSM.g:4962:1: ( ':' )
             {
-            // InternalFSM.g:4915:1: ( ':' )
-            // InternalFSM.g:4916:1: ':'
+            // InternalFSM.g:4962:1: ( ':' )
+            // InternalFSM.g:4963:1: ':'
             {
              before(grammarAccess.getContinuationTransitionAccess().getColonKeyword_2()); 
             match(input,43,FOLLOW_2); 
@@ -14034,14 +14190,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__3"
-    // InternalFSM.g:4929:1: rule__ContinuationTransition__Group__3 : rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ;
+    // InternalFSM.g:4976:1: rule__ContinuationTransition__Group__3 : rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ;
     public final void rule__ContinuationTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4933:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 )
-            // InternalFSM.g:4934:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4
+            // InternalFSM.g:4980:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 )
+            // InternalFSM.g:4981:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4
             {
             pushFollow(FOLLOW_20);
             rule__ContinuationTransition__Group__3__Impl();
@@ -14072,21 +14228,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__3__Impl"
-    // InternalFSM.g:4941:1: rule__ContinuationTransition__Group__3__Impl : ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ;
+    // InternalFSM.g:4988:1: rule__ContinuationTransition__Group__3__Impl : ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ;
     public final void rule__ContinuationTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4945:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) )
-            // InternalFSM.g:4946:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
+            // InternalFSM.g:4992:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) )
+            // InternalFSM.g:4993:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
             {
-            // InternalFSM.g:4946:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
-            // InternalFSM.g:4947:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalFSM.g:4993:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
+            // InternalFSM.g:4994:1: ( rule__ContinuationTransition__FromAssignment_3 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); 
-            // InternalFSM.g:4948:1: ( rule__ContinuationTransition__FromAssignment_3 )
-            // InternalFSM.g:4948:2: rule__ContinuationTransition__FromAssignment_3
+            // InternalFSM.g:4995:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalFSM.g:4995:2: rule__ContinuationTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__FromAssignment_3();
@@ -14119,14 +14275,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__4"
-    // InternalFSM.g:4958:1: rule__ContinuationTransition__Group__4 : rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ;
+    // InternalFSM.g:5005:1: rule__ContinuationTransition__Group__4 : rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ;
     public final void rule__ContinuationTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4962:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 )
-            // InternalFSM.g:4963:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5
+            // InternalFSM.g:5009:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 )
+            // InternalFSM.g:5010:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5
             {
             pushFollow(FOLLOW_21);
             rule__ContinuationTransition__Group__4__Impl();
@@ -14157,17 +14313,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__4__Impl"
-    // InternalFSM.g:4970:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ;
+    // InternalFSM.g:5017:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__ContinuationTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4974:1: ( ( '->' ) )
-            // InternalFSM.g:4975:1: ( '->' )
+            // InternalFSM.g:5021:1: ( ( '->' ) )
+            // InternalFSM.g:5022:1: ( '->' )
             {
-            // InternalFSM.g:4975:1: ( '->' )
-            // InternalFSM.g:4976:1: '->'
+            // InternalFSM.g:5022:1: ( '->' )
+            // InternalFSM.g:5023:1: '->'
             {
              before(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -14194,14 +14350,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__5"
-    // InternalFSM.g:4989:1: rule__ContinuationTransition__Group__5 : rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ;
+    // InternalFSM.g:5036:1: rule__ContinuationTransition__Group__5 : rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ;
     public final void rule__ContinuationTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:4993:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 )
-            // InternalFSM.g:4994:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6
+            // InternalFSM.g:5040:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 )
+            // InternalFSM.g:5041:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6
             {
             pushFollow(FOLLOW_10);
             rule__ContinuationTransition__Group__5__Impl();
@@ -14232,21 +14388,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__5__Impl"
-    // InternalFSM.g:5001:1: rule__ContinuationTransition__Group__5__Impl : ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ;
+    // InternalFSM.g:5048:1: rule__ContinuationTransition__Group__5__Impl : ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ;
     public final void rule__ContinuationTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5005:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) )
-            // InternalFSM.g:5006:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
+            // InternalFSM.g:5052:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) )
+            // InternalFSM.g:5053:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
             {
-            // InternalFSM.g:5006:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
-            // InternalFSM.g:5007:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalFSM.g:5053:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
+            // InternalFSM.g:5054:1: ( rule__ContinuationTransition__ToAssignment_5 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); 
-            // InternalFSM.g:5008:1: ( rule__ContinuationTransition__ToAssignment_5 )
-            // InternalFSM.g:5008:2: rule__ContinuationTransition__ToAssignment_5
+            // InternalFSM.g:5055:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalFSM.g:5055:2: rule__ContinuationTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ToAssignment_5();
@@ -14279,14 +14435,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__6"
-    // InternalFSM.g:5018:1: rule__ContinuationTransition__Group__6 : rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ;
+    // InternalFSM.g:5065:1: rule__ContinuationTransition__Group__6 : rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ;
     public final void rule__ContinuationTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5022:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 )
-            // InternalFSM.g:5023:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7
+            // InternalFSM.g:5069:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 )
+            // InternalFSM.g:5070:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7
             {
             pushFollow(FOLLOW_10);
             rule__ContinuationTransition__Group__6__Impl();
@@ -14317,29 +14473,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__6__Impl"
-    // InternalFSM.g:5030:1: rule__ContinuationTransition__Group__6__Impl : ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ;
+    // InternalFSM.g:5077:1: rule__ContinuationTransition__Group__6__Impl : ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ;
     public final void rule__ContinuationTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5034:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) )
-            // InternalFSM.g:5035:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:5081:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) )
+            // InternalFSM.g:5082:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
             {
-            // InternalFSM.g:5035:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
-            // InternalFSM.g:5036:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            // InternalFSM.g:5082:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:5083:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); 
-            // InternalFSM.g:5037:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
-            int alt53=2;
-            int LA53_0 = input.LA(1);
+            // InternalFSM.g:5084:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            int alt54=2;
+            int LA54_0 = input.LA(1);
 
-            if ( (LA53_0==66) ) {
-                alt53=1;
+            if ( (LA54_0==66) ) {
+                alt54=1;
             }
-            switch (alt53) {
+            switch (alt54) {
                 case 1 :
-                    // InternalFSM.g:5037:2: rule__ContinuationTransition__DocuAssignment_6
+                    // InternalFSM.g:5084:2: rule__ContinuationTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__DocuAssignment_6();
@@ -14375,14 +14531,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__7"
-    // InternalFSM.g:5047:1: rule__ContinuationTransition__Group__7 : rule__ContinuationTransition__Group__7__Impl ;
+    // InternalFSM.g:5094:1: rule__ContinuationTransition__Group__7 : rule__ContinuationTransition__Group__7__Impl ;
     public final void rule__ContinuationTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5051:1: ( rule__ContinuationTransition__Group__7__Impl )
-            // InternalFSM.g:5052:2: rule__ContinuationTransition__Group__7__Impl
+            // InternalFSM.g:5098:1: ( rule__ContinuationTransition__Group__7__Impl )
+            // InternalFSM.g:5099:2: rule__ContinuationTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__7__Impl();
@@ -14408,29 +14564,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__7__Impl"
-    // InternalFSM.g:5058:1: rule__ContinuationTransition__Group__7__Impl : ( ( rule__ContinuationTransition__Group_7__0 )? ) ;
+    // InternalFSM.g:5105:1: rule__ContinuationTransition__Group__7__Impl : ( ( rule__ContinuationTransition__Group_7__0 )? ) ;
     public final void rule__ContinuationTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5062:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) )
-            // InternalFSM.g:5063:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
+            // InternalFSM.g:5109:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) )
+            // InternalFSM.g:5110:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
             {
-            // InternalFSM.g:5063:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
-            // InternalFSM.g:5064:1: ( rule__ContinuationTransition__Group_7__0 )?
+            // InternalFSM.g:5110:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
+            // InternalFSM.g:5111:1: ( rule__ContinuationTransition__Group_7__0 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup_7()); 
-            // InternalFSM.g:5065:1: ( rule__ContinuationTransition__Group_7__0 )?
-            int alt54=2;
-            int LA54_0 = input.LA(1);
+            // InternalFSM.g:5112:1: ( rule__ContinuationTransition__Group_7__0 )?
+            int alt55=2;
+            int LA55_0 = input.LA(1);
 
-            if ( (LA54_0==29) ) {
-                alt54=1;
+            if ( (LA55_0==29) ) {
+                alt55=1;
             }
-            switch (alt54) {
+            switch (alt55) {
                 case 1 :
-                    // InternalFSM.g:5065:2: rule__ContinuationTransition__Group_7__0
+                    // InternalFSM.g:5112:2: rule__ContinuationTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7__0();
@@ -14466,14 +14622,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__0"
-    // InternalFSM.g:5091:1: rule__ContinuationTransition__Group_7__0 : rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ;
+    // InternalFSM.g:5138:1: rule__ContinuationTransition__Group_7__0 : rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ;
     public final void rule__ContinuationTransition__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5095:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 )
-            // InternalFSM.g:5096:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1
+            // InternalFSM.g:5142:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 )
+            // InternalFSM.g:5143:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1
             {
             pushFollow(FOLLOW_22);
             rule__ContinuationTransition__Group_7__0__Impl();
@@ -14504,17 +14660,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__0__Impl"
-    // InternalFSM.g:5103:1: rule__ContinuationTransition__Group_7__0__Impl : ( '{' ) ;
+    // InternalFSM.g:5150:1: rule__ContinuationTransition__Group_7__0__Impl : ( '{' ) ;
     public final void rule__ContinuationTransition__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5107:1: ( ( '{' ) )
-            // InternalFSM.g:5108:1: ( '{' )
+            // InternalFSM.g:5154:1: ( ( '{' ) )
+            // InternalFSM.g:5155:1: ( '{' )
             {
-            // InternalFSM.g:5108:1: ( '{' )
-            // InternalFSM.g:5109:1: '{'
+            // InternalFSM.g:5155:1: ( '{' )
+            // InternalFSM.g:5156:1: '{'
             {
              before(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,29,FOLLOW_2); 
@@ -14541,14 +14697,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__1"
-    // InternalFSM.g:5122:1: rule__ContinuationTransition__Group_7__1 : rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ;
+    // InternalFSM.g:5169:1: rule__ContinuationTransition__Group_7__1 : rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ;
     public final void rule__ContinuationTransition__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5126:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 )
-            // InternalFSM.g:5127:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2
+            // InternalFSM.g:5173:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 )
+            // InternalFSM.g:5174:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2
             {
             pushFollow(FOLLOW_22);
             rule__ContinuationTransition__Group_7__1__Impl();
@@ -14579,29 +14735,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__1__Impl"
-    // InternalFSM.g:5134:1: rule__ContinuationTransition__Group_7__1__Impl : ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ;
+    // InternalFSM.g:5181:1: rule__ContinuationTransition__Group_7__1__Impl : ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ;
     public final void rule__ContinuationTransition__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5138:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) )
-            // InternalFSM.g:5139:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
+            // InternalFSM.g:5185:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) )
+            // InternalFSM.g:5186:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
             {
-            // InternalFSM.g:5139:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
-            // InternalFSM.g:5140:1: ( rule__ContinuationTransition__Group_7_1__0 )?
+            // InternalFSM.g:5186:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
+            // InternalFSM.g:5187:1: ( rule__ContinuationTransition__Group_7_1__0 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); 
-            // InternalFSM.g:5141:1: ( rule__ContinuationTransition__Group_7_1__0 )?
-            int alt55=2;
-            int LA55_0 = input.LA(1);
+            // InternalFSM.g:5188:1: ( rule__ContinuationTransition__Group_7_1__0 )?
+            int alt56=2;
+            int LA56_0 = input.LA(1);
 
-            if ( (LA55_0==46) ) {
-                alt55=1;
+            if ( (LA56_0==46) ) {
+                alt56=1;
             }
-            switch (alt55) {
+            switch (alt56) {
                 case 1 :
-                    // InternalFSM.g:5141:2: rule__ContinuationTransition__Group_7_1__0
+                    // InternalFSM.g:5188:2: rule__ContinuationTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7_1__0();
@@ -14637,14 +14793,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__2"
-    // InternalFSM.g:5151:1: rule__ContinuationTransition__Group_7__2 : rule__ContinuationTransition__Group_7__2__Impl ;
+    // InternalFSM.g:5198:1: rule__ContinuationTransition__Group_7__2 : rule__ContinuationTransition__Group_7__2__Impl ;
     public final void rule__ContinuationTransition__Group_7__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5155:1: ( rule__ContinuationTransition__Group_7__2__Impl )
-            // InternalFSM.g:5156:2: rule__ContinuationTransition__Group_7__2__Impl
+            // InternalFSM.g:5202:1: ( rule__ContinuationTransition__Group_7__2__Impl )
+            // InternalFSM.g:5203:2: rule__ContinuationTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7__2__Impl();
@@ -14670,17 +14826,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__2__Impl"
-    // InternalFSM.g:5162:1: rule__ContinuationTransition__Group_7__2__Impl : ( '}' ) ;
+    // InternalFSM.g:5209:1: rule__ContinuationTransition__Group_7__2__Impl : ( '}' ) ;
     public final void rule__ContinuationTransition__Group_7__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5166:1: ( ( '}' ) )
-            // InternalFSM.g:5167:1: ( '}' )
+            // InternalFSM.g:5213:1: ( ( '}' ) )
+            // InternalFSM.g:5214:1: ( '}' )
             {
-            // InternalFSM.g:5167:1: ( '}' )
-            // InternalFSM.g:5168:1: '}'
+            // InternalFSM.g:5214:1: ( '}' )
+            // InternalFSM.g:5215:1: '}'
             {
              before(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,30,FOLLOW_2); 
@@ -14707,14 +14863,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__0"
-    // InternalFSM.g:5187:1: rule__ContinuationTransition__Group_7_1__0 : rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ;
+    // InternalFSM.g:5234:1: rule__ContinuationTransition__Group_7_1__0 : rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ;
     public final void rule__ContinuationTransition__Group_7_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5191:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 )
-            // InternalFSM.g:5192:2: rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1
+            // InternalFSM.g:5238:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 )
+            // InternalFSM.g:5239:2: rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1
             {
             pushFollow(FOLLOW_12);
             rule__ContinuationTransition__Group_7_1__0__Impl();
@@ -14745,17 +14901,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__0__Impl"
-    // InternalFSM.g:5199:1: rule__ContinuationTransition__Group_7_1__0__Impl : ( 'action' ) ;
+    // InternalFSM.g:5246:1: rule__ContinuationTransition__Group_7_1__0__Impl : ( 'action' ) ;
     public final void rule__ContinuationTransition__Group_7_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5203:1: ( ( 'action' ) )
-            // InternalFSM.g:5204:1: ( 'action' )
+            // InternalFSM.g:5250:1: ( ( 'action' ) )
+            // InternalFSM.g:5251:1: ( 'action' )
             {
-            // InternalFSM.g:5204:1: ( 'action' )
-            // InternalFSM.g:5205:1: 'action'
+            // InternalFSM.g:5251:1: ( 'action' )
+            // InternalFSM.g:5252:1: 'action'
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,46,FOLLOW_2); 
@@ -14782,14 +14938,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__1"
-    // InternalFSM.g:5218:1: rule__ContinuationTransition__Group_7_1__1 : rule__ContinuationTransition__Group_7_1__1__Impl ;
+    // InternalFSM.g:5265:1: rule__ContinuationTransition__Group_7_1__1 : rule__ContinuationTransition__Group_7_1__1__Impl ;
     public final void rule__ContinuationTransition__Group_7_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5222:1: ( rule__ContinuationTransition__Group_7_1__1__Impl )
-            // InternalFSM.g:5223:2: rule__ContinuationTransition__Group_7_1__1__Impl
+            // InternalFSM.g:5269:1: ( rule__ContinuationTransition__Group_7_1__1__Impl )
+            // InternalFSM.g:5270:2: rule__ContinuationTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7_1__1__Impl();
@@ -14815,21 +14971,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__1__Impl"
-    // InternalFSM.g:5229:1: rule__ContinuationTransition__Group_7_1__1__Impl : ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ;
+    // InternalFSM.g:5276:1: rule__ContinuationTransition__Group_7_1__1__Impl : ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ;
     public final void rule__ContinuationTransition__Group_7_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5233:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) )
-            // InternalFSM.g:5234:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
+            // InternalFSM.g:5280:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalFSM.g:5281:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
             {
-            // InternalFSM.g:5234:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
-            // InternalFSM.g:5235:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
+            // InternalFSM.g:5281:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
+            // InternalFSM.g:5282:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); 
-            // InternalFSM.g:5236:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
-            // InternalFSM.g:5236:2: rule__ContinuationTransition__ActionAssignment_7_1_1
+            // InternalFSM.g:5283:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
+            // InternalFSM.g:5283:2: rule__ContinuationTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ActionAssignment_7_1_1();
@@ -14862,14 +15018,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__0"
-    // InternalFSM.g:5250:1: rule__TriggeredTransition__Group__0 : rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ;
+    // InternalFSM.g:5297:1: rule__TriggeredTransition__Group__0 : rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ;
     public final void rule__TriggeredTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5254:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 )
-            // InternalFSM.g:5255:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1
+            // InternalFSM.g:5301:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 )
+            // InternalFSM.g:5302:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1
             {
             pushFollow(FOLLOW_18);
             rule__TriggeredTransition__Group__0__Impl();
@@ -14900,17 +15056,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__0__Impl"
-    // InternalFSM.g:5262:1: rule__TriggeredTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalFSM.g:5309:1: rule__TriggeredTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__TriggeredTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5266:1: ( ( 'Transition' ) )
-            // InternalFSM.g:5267:1: ( 'Transition' )
+            // InternalFSM.g:5313:1: ( ( 'Transition' ) )
+            // InternalFSM.g:5314:1: ( 'Transition' )
             {
-            // InternalFSM.g:5267:1: ( 'Transition' )
-            // InternalFSM.g:5268:1: 'Transition'
+            // InternalFSM.g:5314:1: ( 'Transition' )
+            // InternalFSM.g:5315:1: 'Transition'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); 
             match(input,42,FOLLOW_2); 
@@ -14937,14 +15093,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__1"
-    // InternalFSM.g:5281:1: rule__TriggeredTransition__Group__1 : rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ;
+    // InternalFSM.g:5328:1: rule__TriggeredTransition__Group__1 : rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ;
     public final void rule__TriggeredTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5285:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 )
-            // InternalFSM.g:5286:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2
+            // InternalFSM.g:5332:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 )
+            // InternalFSM.g:5333:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2
             {
             pushFollow(FOLLOW_18);
             rule__TriggeredTransition__Group__1__Impl();
@@ -14975,29 +15131,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__1__Impl"
-    // InternalFSM.g:5293:1: rule__TriggeredTransition__Group__1__Impl : ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ;
+    // InternalFSM.g:5340:1: rule__TriggeredTransition__Group__1__Impl : ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ;
     public final void rule__TriggeredTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5297:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) )
-            // InternalFSM.g:5298:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
+            // InternalFSM.g:5344:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) )
+            // InternalFSM.g:5345:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
             {
-            // InternalFSM.g:5298:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
-            // InternalFSM.g:5299:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            // InternalFSM.g:5345:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
+            // InternalFSM.g:5346:1: ( rule__TriggeredTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); 
-            // InternalFSM.g:5300:1: ( rule__TriggeredTransition__NameAssignment_1 )?
-            int alt56=2;
-            int LA56_0 = input.LA(1);
+            // InternalFSM.g:5347:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            int alt57=2;
+            int LA57_0 = input.LA(1);
 
-            if ( (LA56_0==RULE_ID) ) {
-                alt56=1;
+            if ( (LA57_0==RULE_ID) ) {
+                alt57=1;
             }
-            switch (alt56) {
+            switch (alt57) {
                 case 1 :
-                    // InternalFSM.g:5300:2: rule__TriggeredTransition__NameAssignment_1
+                    // InternalFSM.g:5347:2: rule__TriggeredTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__NameAssignment_1();
@@ -15033,14 +15189,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__2"
-    // InternalFSM.g:5310:1: rule__TriggeredTransition__Group__2 : rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ;
+    // InternalFSM.g:5357:1: rule__TriggeredTransition__Group__2 : rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ;
     public final void rule__TriggeredTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5314:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 )
-            // InternalFSM.g:5315:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3
+            // InternalFSM.g:5361:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 )
+            // InternalFSM.g:5362:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3
             {
             pushFollow(FOLLOW_21);
             rule__TriggeredTransition__Group__2__Impl();
@@ -15071,17 +15227,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__2__Impl"
-    // InternalFSM.g:5322:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ;
+    // InternalFSM.g:5369:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__TriggeredTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5326:1: ( ( ':' ) )
-            // InternalFSM.g:5327:1: ( ':' )
+            // InternalFSM.g:5373:1: ( ( ':' ) )
+            // InternalFSM.g:5374:1: ( ':' )
             {
-            // InternalFSM.g:5327:1: ( ':' )
-            // InternalFSM.g:5328:1: ':'
+            // InternalFSM.g:5374:1: ( ':' )
+            // InternalFSM.g:5375:1: ':'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2()); 
             match(input,43,FOLLOW_2); 
@@ -15108,14 +15264,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__3"
-    // InternalFSM.g:5341:1: rule__TriggeredTransition__Group__3 : rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ;
+    // InternalFSM.g:5388:1: rule__TriggeredTransition__Group__3 : rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ;
     public final void rule__TriggeredTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5345:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 )
-            // InternalFSM.g:5346:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4
+            // InternalFSM.g:5392:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 )
+            // InternalFSM.g:5393:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4
             {
             pushFollow(FOLLOW_20);
             rule__TriggeredTransition__Group__3__Impl();
@@ -15146,21 +15302,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__3__Impl"
-    // InternalFSM.g:5353:1: rule__TriggeredTransition__Group__3__Impl : ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ;
+    // InternalFSM.g:5400:1: rule__TriggeredTransition__Group__3__Impl : ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ;
     public final void rule__TriggeredTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5357:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) )
-            // InternalFSM.g:5358:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
+            // InternalFSM.g:5404:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) )
+            // InternalFSM.g:5405:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
             {
-            // InternalFSM.g:5358:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
-            // InternalFSM.g:5359:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalFSM.g:5405:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
+            // InternalFSM.g:5406:1: ( rule__TriggeredTransition__FromAssignment_3 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); 
-            // InternalFSM.g:5360:1: ( rule__TriggeredTransition__FromAssignment_3 )
-            // InternalFSM.g:5360:2: rule__TriggeredTransition__FromAssignment_3
+            // InternalFSM.g:5407:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalFSM.g:5407:2: rule__TriggeredTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__FromAssignment_3();
@@ -15193,14 +15349,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__4"
-    // InternalFSM.g:5370:1: rule__TriggeredTransition__Group__4 : rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ;
+    // InternalFSM.g:5417:1: rule__TriggeredTransition__Group__4 : rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ;
     public final void rule__TriggeredTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5374:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 )
-            // InternalFSM.g:5375:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5
+            // InternalFSM.g:5421:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 )
+            // InternalFSM.g:5422:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5
             {
             pushFollow(FOLLOW_21);
             rule__TriggeredTransition__Group__4__Impl();
@@ -15231,17 +15387,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__4__Impl"
-    // InternalFSM.g:5382:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ;
+    // InternalFSM.g:5429:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__TriggeredTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5386:1: ( ( '->' ) )
-            // InternalFSM.g:5387:1: ( '->' )
+            // InternalFSM.g:5433:1: ( ( '->' ) )
+            // InternalFSM.g:5434:1: ( '->' )
             {
-            // InternalFSM.g:5387:1: ( '->' )
-            // InternalFSM.g:5388:1: '->'
+            // InternalFSM.g:5434:1: ( '->' )
+            // InternalFSM.g:5435:1: '->'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -15268,14 +15424,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__5"
-    // InternalFSM.g:5401:1: rule__TriggeredTransition__Group__5 : rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ;
+    // InternalFSM.g:5448:1: rule__TriggeredTransition__Group__5 : rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ;
     public final void rule__TriggeredTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5405:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 )
-            // InternalFSM.g:5406:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6
+            // InternalFSM.g:5452:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 )
+            // InternalFSM.g:5453:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6
             {
             pushFollow(FOLLOW_10);
             rule__TriggeredTransition__Group__5__Impl();
@@ -15306,21 +15462,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__5__Impl"
-    // InternalFSM.g:5413:1: rule__TriggeredTransition__Group__5__Impl : ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ;
+    // InternalFSM.g:5460:1: rule__TriggeredTransition__Group__5__Impl : ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ;
     public final void rule__TriggeredTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5417:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) )
-            // InternalFSM.g:5418:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
+            // InternalFSM.g:5464:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) )
+            // InternalFSM.g:5465:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
             {
-            // InternalFSM.g:5418:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
-            // InternalFSM.g:5419:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalFSM.g:5465:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
+            // InternalFSM.g:5466:1: ( rule__TriggeredTransition__ToAssignment_5 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); 
-            // InternalFSM.g:5420:1: ( rule__TriggeredTransition__ToAssignment_5 )
-            // InternalFSM.g:5420:2: rule__TriggeredTransition__ToAssignment_5
+            // InternalFSM.g:5467:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalFSM.g:5467:2: rule__TriggeredTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ToAssignment_5();
@@ -15353,14 +15509,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__6"
-    // InternalFSM.g:5430:1: rule__TriggeredTransition__Group__6 : rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ;
+    // InternalFSM.g:5477:1: rule__TriggeredTransition__Group__6 : rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ;
     public final void rule__TriggeredTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5434:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 )
-            // InternalFSM.g:5435:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7
+            // InternalFSM.g:5481:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 )
+            // InternalFSM.g:5482:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7
             {
             pushFollow(FOLLOW_10);
             rule__TriggeredTransition__Group__6__Impl();
@@ -15391,29 +15547,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__6__Impl"
-    // InternalFSM.g:5442:1: rule__TriggeredTransition__Group__6__Impl : ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ;
+    // InternalFSM.g:5489:1: rule__TriggeredTransition__Group__6__Impl : ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ;
     public final void rule__TriggeredTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5446:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) )
-            // InternalFSM.g:5447:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:5493:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) )
+            // InternalFSM.g:5494:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
             {
-            // InternalFSM.g:5447:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
-            // InternalFSM.g:5448:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            // InternalFSM.g:5494:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:5495:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); 
-            // InternalFSM.g:5449:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
-            int alt57=2;
-            int LA57_0 = input.LA(1);
+            // InternalFSM.g:5496:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            int alt58=2;
+            int LA58_0 = input.LA(1);
 
-            if ( (LA57_0==66) ) {
-                alt57=1;
+            if ( (LA58_0==66) ) {
+                alt58=1;
             }
-            switch (alt57) {
+            switch (alt58) {
                 case 1 :
-                    // InternalFSM.g:5449:2: rule__TriggeredTransition__DocuAssignment_6
+                    // InternalFSM.g:5496:2: rule__TriggeredTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__DocuAssignment_6();
@@ -15449,14 +15605,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__7"
-    // InternalFSM.g:5459:1: rule__TriggeredTransition__Group__7 : rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ;
+    // InternalFSM.g:5506:1: rule__TriggeredTransition__Group__7 : rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ;
     public final void rule__TriggeredTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5463:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 )
-            // InternalFSM.g:5464:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8
+            // InternalFSM.g:5510:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 )
+            // InternalFSM.g:5511:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8
             {
             pushFollow(FOLLOW_23);
             rule__TriggeredTransition__Group__7__Impl();
@@ -15487,17 +15643,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__7__Impl"
-    // InternalFSM.g:5471:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ;
+    // InternalFSM.g:5518:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__TriggeredTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5475:1: ( ( '{' ) )
-            // InternalFSM.g:5476:1: ( '{' )
+            // InternalFSM.g:5522:1: ( ( '{' ) )
+            // InternalFSM.g:5523:1: ( '{' )
             {
-            // InternalFSM.g:5476:1: ( '{' )
-            // InternalFSM.g:5477:1: '{'
+            // InternalFSM.g:5523:1: ( '{' )
+            // InternalFSM.g:5524:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,29,FOLLOW_2); 
@@ -15524,14 +15680,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__8"
-    // InternalFSM.g:5490:1: rule__TriggeredTransition__Group__8 : rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ;
+    // InternalFSM.g:5537:1: rule__TriggeredTransition__Group__8 : rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ;
     public final void rule__TriggeredTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5494:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 )
-            // InternalFSM.g:5495:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9
+            // InternalFSM.g:5541:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 )
+            // InternalFSM.g:5542:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9
             {
             pushFollow(FOLLOW_7);
             rule__TriggeredTransition__Group__8__Impl();
@@ -15562,17 +15718,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__8__Impl"
-    // InternalFSM.g:5502:1: rule__TriggeredTransition__Group__8__Impl : ( 'triggers' ) ;
+    // InternalFSM.g:5549:1: rule__TriggeredTransition__Group__8__Impl : ( 'triggers' ) ;
     public final void rule__TriggeredTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5506:1: ( ( 'triggers' ) )
-            // InternalFSM.g:5507:1: ( 'triggers' )
+            // InternalFSM.g:5553:1: ( ( 'triggers' ) )
+            // InternalFSM.g:5554:1: ( 'triggers' )
             {
-            // InternalFSM.g:5507:1: ( 'triggers' )
-            // InternalFSM.g:5508:1: 'triggers'
+            // InternalFSM.g:5554:1: ( 'triggers' )
+            // InternalFSM.g:5555:1: 'triggers'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); 
             match(input,47,FOLLOW_2); 
@@ -15599,14 +15755,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__9"
-    // InternalFSM.g:5521:1: rule__TriggeredTransition__Group__9 : rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ;
+    // InternalFSM.g:5568:1: rule__TriggeredTransition__Group__9 : rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ;
     public final void rule__TriggeredTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5525:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 )
-            // InternalFSM.g:5526:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10
+            // InternalFSM.g:5572:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 )
+            // InternalFSM.g:5573:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10
             {
             pushFollow(FOLLOW_24);
             rule__TriggeredTransition__Group__9__Impl();
@@ -15637,17 +15793,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__9__Impl"
-    // InternalFSM.g:5533:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ;
+    // InternalFSM.g:5580:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ;
     public final void rule__TriggeredTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5537:1: ( ( '{' ) )
-            // InternalFSM.g:5538:1: ( '{' )
+            // InternalFSM.g:5584:1: ( ( '{' ) )
+            // InternalFSM.g:5585:1: ( '{' )
             {
-            // InternalFSM.g:5538:1: ( '{' )
-            // InternalFSM.g:5539:1: '{'
+            // InternalFSM.g:5585:1: ( '{' )
+            // InternalFSM.g:5586:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); 
             match(input,29,FOLLOW_2); 
@@ -15674,14 +15830,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__10"
-    // InternalFSM.g:5552:1: rule__TriggeredTransition__Group__10 : rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ;
+    // InternalFSM.g:5599:1: rule__TriggeredTransition__Group__10 : rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ;
     public final void rule__TriggeredTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5556:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 )
-            // InternalFSM.g:5557:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11
+            // InternalFSM.g:5603:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 )
+            // InternalFSM.g:5604:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11
             {
             pushFollow(FOLLOW_25);
             rule__TriggeredTransition__Group__10__Impl();
@@ -15712,21 +15868,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__10__Impl"
-    // InternalFSM.g:5564:1: rule__TriggeredTransition__Group__10__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ;
+    // InternalFSM.g:5611:1: rule__TriggeredTransition__Group__10__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ;
     public final void rule__TriggeredTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5568:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) )
-            // InternalFSM.g:5569:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
+            // InternalFSM.g:5615:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) )
+            // InternalFSM.g:5616:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
             {
-            // InternalFSM.g:5569:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
-            // InternalFSM.g:5570:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalFSM.g:5616:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
+            // InternalFSM.g:5617:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); 
-            // InternalFSM.g:5571:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
-            // InternalFSM.g:5571:2: rule__TriggeredTransition__TriggersAssignment_10
+            // InternalFSM.g:5618:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalFSM.g:5618:2: rule__TriggeredTransition__TriggersAssignment_10
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_10();
@@ -15759,14 +15915,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__11"
-    // InternalFSM.g:5581:1: rule__TriggeredTransition__Group__11 : rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ;
+    // InternalFSM.g:5628:1: rule__TriggeredTransition__Group__11 : rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ;
     public final void rule__TriggeredTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5585:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 )
-            // InternalFSM.g:5586:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12
+            // InternalFSM.g:5632:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 )
+            // InternalFSM.g:5633:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12
             {
             pushFollow(FOLLOW_25);
             rule__TriggeredTransition__Group__11__Impl();
@@ -15797,33 +15953,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__11__Impl"
-    // InternalFSM.g:5593:1: rule__TriggeredTransition__Group__11__Impl : ( ( rule__TriggeredTransition__Group_11__0 )* ) ;
+    // InternalFSM.g:5640:1: rule__TriggeredTransition__Group__11__Impl : ( ( rule__TriggeredTransition__Group_11__0 )* ) ;
     public final void rule__TriggeredTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5597:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) )
-            // InternalFSM.g:5598:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
+            // InternalFSM.g:5644:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) )
+            // InternalFSM.g:5645:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
             {
-            // InternalFSM.g:5598:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
-            // InternalFSM.g:5599:1: ( rule__TriggeredTransition__Group_11__0 )*
+            // InternalFSM.g:5645:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
+            // InternalFSM.g:5646:1: ( rule__TriggeredTransition__Group_11__0 )*
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); 
-            // InternalFSM.g:5600:1: ( rule__TriggeredTransition__Group_11__0 )*
-            loop58:
+            // InternalFSM.g:5647:1: ( rule__TriggeredTransition__Group_11__0 )*
+            loop59:
             do {
-                int alt58=2;
-                int LA58_0 = input.LA(1);
+                int alt59=2;
+                int LA59_0 = input.LA(1);
 
-                if ( (LA58_0==48) ) {
-                    alt58=1;
+                if ( (LA59_0==48) ) {
+                    alt59=1;
                 }
 
 
-                switch (alt58) {
+                switch (alt59) {
             	case 1 :
-            	    // InternalFSM.g:5600:2: rule__TriggeredTransition__Group_11__0
+            	    // InternalFSM.g:5647:2: rule__TriggeredTransition__Group_11__0
             	    {
             	    pushFollow(FOLLOW_26);
             	    rule__TriggeredTransition__Group_11__0();
@@ -15835,7 +15991,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop58;
+            	    break loop59;
                 }
             } while (true);
 
@@ -15862,14 +16018,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__12"
-    // InternalFSM.g:5610:1: rule__TriggeredTransition__Group__12 : rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ;
+    // InternalFSM.g:5657:1: rule__TriggeredTransition__Group__12 : rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ;
     public final void rule__TriggeredTransition__Group__12() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5614:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 )
-            // InternalFSM.g:5615:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13
+            // InternalFSM.g:5661:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 )
+            // InternalFSM.g:5662:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13
             {
             pushFollow(FOLLOW_22);
             rule__TriggeredTransition__Group__12__Impl();
@@ -15900,17 +16056,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__12__Impl"
-    // InternalFSM.g:5622:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ;
+    // InternalFSM.g:5669:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ;
     public final void rule__TriggeredTransition__Group__12__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5626:1: ( ( '}' ) )
-            // InternalFSM.g:5627:1: ( '}' )
+            // InternalFSM.g:5673:1: ( ( '}' ) )
+            // InternalFSM.g:5674:1: ( '}' )
             {
-            // InternalFSM.g:5627:1: ( '}' )
-            // InternalFSM.g:5628:1: '}'
+            // InternalFSM.g:5674:1: ( '}' )
+            // InternalFSM.g:5675:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); 
             match(input,30,FOLLOW_2); 
@@ -15937,14 +16093,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__13"
-    // InternalFSM.g:5641:1: rule__TriggeredTransition__Group__13 : rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ;
+    // InternalFSM.g:5688:1: rule__TriggeredTransition__Group__13 : rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ;
     public final void rule__TriggeredTransition__Group__13() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5645:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 )
-            // InternalFSM.g:5646:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14
+            // InternalFSM.g:5692:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 )
+            // InternalFSM.g:5693:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14
             {
             pushFollow(FOLLOW_22);
             rule__TriggeredTransition__Group__13__Impl();
@@ -15975,29 +16131,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__13__Impl"
-    // InternalFSM.g:5653:1: rule__TriggeredTransition__Group__13__Impl : ( ( rule__TriggeredTransition__Group_13__0 )? ) ;
+    // InternalFSM.g:5700:1: rule__TriggeredTransition__Group__13__Impl : ( ( rule__TriggeredTransition__Group_13__0 )? ) ;
     public final void rule__TriggeredTransition__Group__13__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5657:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) )
-            // InternalFSM.g:5658:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
+            // InternalFSM.g:5704:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) )
+            // InternalFSM.g:5705:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
             {
-            // InternalFSM.g:5658:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
-            // InternalFSM.g:5659:1: ( rule__TriggeredTransition__Group_13__0 )?
+            // InternalFSM.g:5705:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
+            // InternalFSM.g:5706:1: ( rule__TriggeredTransition__Group_13__0 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); 
-            // InternalFSM.g:5660:1: ( rule__TriggeredTransition__Group_13__0 )?
-            int alt59=2;
-            int LA59_0 = input.LA(1);
+            // InternalFSM.g:5707:1: ( rule__TriggeredTransition__Group_13__0 )?
+            int alt60=2;
+            int LA60_0 = input.LA(1);
 
-            if ( (LA59_0==46) ) {
-                alt59=1;
+            if ( (LA60_0==46) ) {
+                alt60=1;
             }
-            switch (alt59) {
+            switch (alt60) {
                 case 1 :
-                    // InternalFSM.g:5660:2: rule__TriggeredTransition__Group_13__0
+                    // InternalFSM.g:5707:2: rule__TriggeredTransition__Group_13__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__Group_13__0();
@@ -16033,14 +16189,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__14"
-    // InternalFSM.g:5670:1: rule__TriggeredTransition__Group__14 : rule__TriggeredTransition__Group__14__Impl ;
+    // InternalFSM.g:5717:1: rule__TriggeredTransition__Group__14 : rule__TriggeredTransition__Group__14__Impl ;
     public final void rule__TriggeredTransition__Group__14() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5674:1: ( rule__TriggeredTransition__Group__14__Impl )
-            // InternalFSM.g:5675:2: rule__TriggeredTransition__Group__14__Impl
+            // InternalFSM.g:5721:1: ( rule__TriggeredTransition__Group__14__Impl )
+            // InternalFSM.g:5722:2: rule__TriggeredTransition__Group__14__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__14__Impl();
@@ -16066,17 +16222,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__14__Impl"
-    // InternalFSM.g:5681:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ;
+    // InternalFSM.g:5728:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ;
     public final void rule__TriggeredTransition__Group__14__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5685:1: ( ( '}' ) )
-            // InternalFSM.g:5686:1: ( '}' )
+            // InternalFSM.g:5732:1: ( ( '}' ) )
+            // InternalFSM.g:5733:1: ( '}' )
             {
-            // InternalFSM.g:5686:1: ( '}' )
-            // InternalFSM.g:5687:1: '}'
+            // InternalFSM.g:5733:1: ( '}' )
+            // InternalFSM.g:5734:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); 
             match(input,30,FOLLOW_2); 
@@ -16103,14 +16259,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__0"
-    // InternalFSM.g:5730:1: rule__TriggeredTransition__Group_11__0 : rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ;
+    // InternalFSM.g:5777:1: rule__TriggeredTransition__Group_11__0 : rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ;
     public final void rule__TriggeredTransition__Group_11__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5734:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 )
-            // InternalFSM.g:5735:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1
+            // InternalFSM.g:5781:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 )
+            // InternalFSM.g:5782:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1
             {
             pushFollow(FOLLOW_24);
             rule__TriggeredTransition__Group_11__0__Impl();
@@ -16141,17 +16297,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__0__Impl"
-    // InternalFSM.g:5742:1: rule__TriggeredTransition__Group_11__0__Impl : ( 'or' ) ;
+    // InternalFSM.g:5789:1: rule__TriggeredTransition__Group_11__0__Impl : ( 'or' ) ;
     public final void rule__TriggeredTransition__Group_11__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5746:1: ( ( 'or' ) )
-            // InternalFSM.g:5747:1: ( 'or' )
+            // InternalFSM.g:5793:1: ( ( 'or' ) )
+            // InternalFSM.g:5794:1: ( 'or' )
             {
-            // InternalFSM.g:5747:1: ( 'or' )
-            // InternalFSM.g:5748:1: 'or'
+            // InternalFSM.g:5794:1: ( 'or' )
+            // InternalFSM.g:5795:1: 'or'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); 
             match(input,48,FOLLOW_2); 
@@ -16178,14 +16334,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__1"
-    // InternalFSM.g:5761:1: rule__TriggeredTransition__Group_11__1 : rule__TriggeredTransition__Group_11__1__Impl ;
+    // InternalFSM.g:5808:1: rule__TriggeredTransition__Group_11__1 : rule__TriggeredTransition__Group_11__1__Impl ;
     public final void rule__TriggeredTransition__Group_11__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5765:1: ( rule__TriggeredTransition__Group_11__1__Impl )
-            // InternalFSM.g:5766:2: rule__TriggeredTransition__Group_11__1__Impl
+            // InternalFSM.g:5812:1: ( rule__TriggeredTransition__Group_11__1__Impl )
+            // InternalFSM.g:5813:2: rule__TriggeredTransition__Group_11__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_11__1__Impl();
@@ -16211,21 +16367,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__1__Impl"
-    // InternalFSM.g:5772:1: rule__TriggeredTransition__Group_11__1__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ;
+    // InternalFSM.g:5819:1: rule__TriggeredTransition__Group_11__1__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ;
     public final void rule__TriggeredTransition__Group_11__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5776:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) )
-            // InternalFSM.g:5777:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
+            // InternalFSM.g:5823:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) )
+            // InternalFSM.g:5824:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
             {
-            // InternalFSM.g:5777:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
-            // InternalFSM.g:5778:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
+            // InternalFSM.g:5824:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
+            // InternalFSM.g:5825:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); 
-            // InternalFSM.g:5779:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
-            // InternalFSM.g:5779:2: rule__TriggeredTransition__TriggersAssignment_11_1
+            // InternalFSM.g:5826:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
+            // InternalFSM.g:5826:2: rule__TriggeredTransition__TriggersAssignment_11_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_11_1();
@@ -16258,14 +16414,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__0"
-    // InternalFSM.g:5793:1: rule__TriggeredTransition__Group_13__0 : rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ;
+    // InternalFSM.g:5840:1: rule__TriggeredTransition__Group_13__0 : rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ;
     public final void rule__TriggeredTransition__Group_13__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5797:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 )
-            // InternalFSM.g:5798:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1
+            // InternalFSM.g:5844:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 )
+            // InternalFSM.g:5845:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1
             {
             pushFollow(FOLLOW_12);
             rule__TriggeredTransition__Group_13__0__Impl();
@@ -16296,17 +16452,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__0__Impl"
-    // InternalFSM.g:5805:1: rule__TriggeredTransition__Group_13__0__Impl : ( 'action' ) ;
+    // InternalFSM.g:5852:1: rule__TriggeredTransition__Group_13__0__Impl : ( 'action' ) ;
     public final void rule__TriggeredTransition__Group_13__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5809:1: ( ( 'action' ) )
-            // InternalFSM.g:5810:1: ( 'action' )
+            // InternalFSM.g:5856:1: ( ( 'action' ) )
+            // InternalFSM.g:5857:1: ( 'action' )
             {
-            // InternalFSM.g:5810:1: ( 'action' )
-            // InternalFSM.g:5811:1: 'action'
+            // InternalFSM.g:5857:1: ( 'action' )
+            // InternalFSM.g:5858:1: 'action'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); 
             match(input,46,FOLLOW_2); 
@@ -16333,14 +16489,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__1"
-    // InternalFSM.g:5824:1: rule__TriggeredTransition__Group_13__1 : rule__TriggeredTransition__Group_13__1__Impl ;
+    // InternalFSM.g:5871:1: rule__TriggeredTransition__Group_13__1 : rule__TriggeredTransition__Group_13__1__Impl ;
     public final void rule__TriggeredTransition__Group_13__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5828:1: ( rule__TriggeredTransition__Group_13__1__Impl )
-            // InternalFSM.g:5829:2: rule__TriggeredTransition__Group_13__1__Impl
+            // InternalFSM.g:5875:1: ( rule__TriggeredTransition__Group_13__1__Impl )
+            // InternalFSM.g:5876:2: rule__TriggeredTransition__Group_13__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_13__1__Impl();
@@ -16366,21 +16522,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__1__Impl"
-    // InternalFSM.g:5835:1: rule__TriggeredTransition__Group_13__1__Impl : ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ;
+    // InternalFSM.g:5882:1: rule__TriggeredTransition__Group_13__1__Impl : ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ;
     public final void rule__TriggeredTransition__Group_13__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5839:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) )
-            // InternalFSM.g:5840:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
+            // InternalFSM.g:5886:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) )
+            // InternalFSM.g:5887:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
             {
-            // InternalFSM.g:5840:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
-            // InternalFSM.g:5841:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
+            // InternalFSM.g:5887:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
+            // InternalFSM.g:5888:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); 
-            // InternalFSM.g:5842:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
-            // InternalFSM.g:5842:2: rule__TriggeredTransition__ActionAssignment_13_1
+            // InternalFSM.g:5889:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
+            // InternalFSM.g:5889:2: rule__TriggeredTransition__ActionAssignment_13_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ActionAssignment_13_1();
@@ -16413,14 +16569,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__0"
-    // InternalFSM.g:5856:1: rule__GuardedTransition__Group__0 : rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ;
+    // InternalFSM.g:5903:1: rule__GuardedTransition__Group__0 : rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ;
     public final void rule__GuardedTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5860:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 )
-            // InternalFSM.g:5861:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1
+            // InternalFSM.g:5907:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 )
+            // InternalFSM.g:5908:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1
             {
             pushFollow(FOLLOW_18);
             rule__GuardedTransition__Group__0__Impl();
@@ -16451,17 +16607,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__0__Impl"
-    // InternalFSM.g:5868:1: rule__GuardedTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalFSM.g:5915:1: rule__GuardedTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__GuardedTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5872:1: ( ( 'Transition' ) )
-            // InternalFSM.g:5873:1: ( 'Transition' )
+            // InternalFSM.g:5919:1: ( ( 'Transition' ) )
+            // InternalFSM.g:5920:1: ( 'Transition' )
             {
-            // InternalFSM.g:5873:1: ( 'Transition' )
-            // InternalFSM.g:5874:1: 'Transition'
+            // InternalFSM.g:5920:1: ( 'Transition' )
+            // InternalFSM.g:5921:1: 'Transition'
             {
              before(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); 
             match(input,42,FOLLOW_2); 
@@ -16488,14 +16644,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__1"
-    // InternalFSM.g:5887:1: rule__GuardedTransition__Group__1 : rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ;
+    // InternalFSM.g:5934:1: rule__GuardedTransition__Group__1 : rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ;
     public final void rule__GuardedTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5891:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 )
-            // InternalFSM.g:5892:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2
+            // InternalFSM.g:5938:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 )
+            // InternalFSM.g:5939:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2
             {
             pushFollow(FOLLOW_18);
             rule__GuardedTransition__Group__1__Impl();
@@ -16526,29 +16682,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__1__Impl"
-    // InternalFSM.g:5899:1: rule__GuardedTransition__Group__1__Impl : ( ( rule__GuardedTransition__NameAssignment_1 )? ) ;
+    // InternalFSM.g:5946:1: rule__GuardedTransition__Group__1__Impl : ( ( rule__GuardedTransition__NameAssignment_1 )? ) ;
     public final void rule__GuardedTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5903:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) )
-            // InternalFSM.g:5904:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
+            // InternalFSM.g:5950:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) )
+            // InternalFSM.g:5951:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
             {
-            // InternalFSM.g:5904:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
-            // InternalFSM.g:5905:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            // InternalFSM.g:5951:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
+            // InternalFSM.g:5952:1: ( rule__GuardedTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); 
-            // InternalFSM.g:5906:1: ( rule__GuardedTransition__NameAssignment_1 )?
-            int alt60=2;
-            int LA60_0 = input.LA(1);
+            // InternalFSM.g:5953:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            int alt61=2;
+            int LA61_0 = input.LA(1);
 
-            if ( (LA60_0==RULE_ID) ) {
-                alt60=1;
+            if ( (LA61_0==RULE_ID) ) {
+                alt61=1;
             }
-            switch (alt60) {
+            switch (alt61) {
                 case 1 :
-                    // InternalFSM.g:5906:2: rule__GuardedTransition__NameAssignment_1
+                    // InternalFSM.g:5953:2: rule__GuardedTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__NameAssignment_1();
@@ -16584,14 +16740,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__2"
-    // InternalFSM.g:5916:1: rule__GuardedTransition__Group__2 : rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ;
+    // InternalFSM.g:5963:1: rule__GuardedTransition__Group__2 : rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ;
     public final void rule__GuardedTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5920:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 )
-            // InternalFSM.g:5921:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3
+            // InternalFSM.g:5967:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 )
+            // InternalFSM.g:5968:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3
             {
             pushFollow(FOLLOW_21);
             rule__GuardedTransition__Group__2__Impl();
@@ -16622,17 +16778,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__2__Impl"
-    // InternalFSM.g:5928:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ;
+    // InternalFSM.g:5975:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__GuardedTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5932:1: ( ( ':' ) )
-            // InternalFSM.g:5933:1: ( ':' )
+            // InternalFSM.g:5979:1: ( ( ':' ) )
+            // InternalFSM.g:5980:1: ( ':' )
             {
-            // InternalFSM.g:5933:1: ( ':' )
-            // InternalFSM.g:5934:1: ':'
+            // InternalFSM.g:5980:1: ( ':' )
+            // InternalFSM.g:5981:1: ':'
             {
              before(grammarAccess.getGuardedTransitionAccess().getColonKeyword_2()); 
             match(input,43,FOLLOW_2); 
@@ -16659,14 +16815,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__3"
-    // InternalFSM.g:5947:1: rule__GuardedTransition__Group__3 : rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ;
+    // InternalFSM.g:5994:1: rule__GuardedTransition__Group__3 : rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ;
     public final void rule__GuardedTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5951:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 )
-            // InternalFSM.g:5952:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4
+            // InternalFSM.g:5998:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 )
+            // InternalFSM.g:5999:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4
             {
             pushFollow(FOLLOW_20);
             rule__GuardedTransition__Group__3__Impl();
@@ -16697,21 +16853,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__3__Impl"
-    // InternalFSM.g:5959:1: rule__GuardedTransition__Group__3__Impl : ( ( rule__GuardedTransition__FromAssignment_3 ) ) ;
+    // InternalFSM.g:6006:1: rule__GuardedTransition__Group__3__Impl : ( ( rule__GuardedTransition__FromAssignment_3 ) ) ;
     public final void rule__GuardedTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5963:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) )
-            // InternalFSM.g:5964:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
+            // InternalFSM.g:6010:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) )
+            // InternalFSM.g:6011:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
             {
-            // InternalFSM.g:5964:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
-            // InternalFSM.g:5965:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalFSM.g:6011:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
+            // InternalFSM.g:6012:1: ( rule__GuardedTransition__FromAssignment_3 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); 
-            // InternalFSM.g:5966:1: ( rule__GuardedTransition__FromAssignment_3 )
-            // InternalFSM.g:5966:2: rule__GuardedTransition__FromAssignment_3
+            // InternalFSM.g:6013:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalFSM.g:6013:2: rule__GuardedTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__FromAssignment_3();
@@ -16744,14 +16900,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__4"
-    // InternalFSM.g:5976:1: rule__GuardedTransition__Group__4 : rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ;
+    // InternalFSM.g:6023:1: rule__GuardedTransition__Group__4 : rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ;
     public final void rule__GuardedTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5980:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 )
-            // InternalFSM.g:5981:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5
+            // InternalFSM.g:6027:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 )
+            // InternalFSM.g:6028:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5
             {
             pushFollow(FOLLOW_21);
             rule__GuardedTransition__Group__4__Impl();
@@ -16782,17 +16938,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__4__Impl"
-    // InternalFSM.g:5988:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ;
+    // InternalFSM.g:6035:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__GuardedTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:5992:1: ( ( '->' ) )
-            // InternalFSM.g:5993:1: ( '->' )
+            // InternalFSM.g:6039:1: ( ( '->' ) )
+            // InternalFSM.g:6040:1: ( '->' )
             {
-            // InternalFSM.g:5993:1: ( '->' )
-            // InternalFSM.g:5994:1: '->'
+            // InternalFSM.g:6040:1: ( '->' )
+            // InternalFSM.g:6041:1: '->'
             {
              before(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -16819,14 +16975,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__5"
-    // InternalFSM.g:6007:1: rule__GuardedTransition__Group__5 : rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ;
+    // InternalFSM.g:6054:1: rule__GuardedTransition__Group__5 : rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ;
     public final void rule__GuardedTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6011:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 )
-            // InternalFSM.g:6012:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6
+            // InternalFSM.g:6058:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 )
+            // InternalFSM.g:6059:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6
             {
             pushFollow(FOLLOW_10);
             rule__GuardedTransition__Group__5__Impl();
@@ -16857,21 +17013,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__5__Impl"
-    // InternalFSM.g:6019:1: rule__GuardedTransition__Group__5__Impl : ( ( rule__GuardedTransition__ToAssignment_5 ) ) ;
+    // InternalFSM.g:6066:1: rule__GuardedTransition__Group__5__Impl : ( ( rule__GuardedTransition__ToAssignment_5 ) ) ;
     public final void rule__GuardedTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6023:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) )
-            // InternalFSM.g:6024:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
+            // InternalFSM.g:6070:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) )
+            // InternalFSM.g:6071:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
             {
-            // InternalFSM.g:6024:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
-            // InternalFSM.g:6025:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalFSM.g:6071:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
+            // InternalFSM.g:6072:1: ( rule__GuardedTransition__ToAssignment_5 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); 
-            // InternalFSM.g:6026:1: ( rule__GuardedTransition__ToAssignment_5 )
-            // InternalFSM.g:6026:2: rule__GuardedTransition__ToAssignment_5
+            // InternalFSM.g:6073:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalFSM.g:6073:2: rule__GuardedTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ToAssignment_5();
@@ -16904,14 +17060,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__6"
-    // InternalFSM.g:6036:1: rule__GuardedTransition__Group__6 : rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ;
+    // InternalFSM.g:6083:1: rule__GuardedTransition__Group__6 : rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ;
     public final void rule__GuardedTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6040:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 )
-            // InternalFSM.g:6041:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7
+            // InternalFSM.g:6087:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 )
+            // InternalFSM.g:6088:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7
             {
             pushFollow(FOLLOW_10);
             rule__GuardedTransition__Group__6__Impl();
@@ -16942,29 +17098,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__6__Impl"
-    // InternalFSM.g:6048:1: rule__GuardedTransition__Group__6__Impl : ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ;
+    // InternalFSM.g:6095:1: rule__GuardedTransition__Group__6__Impl : ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ;
     public final void rule__GuardedTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6052:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) )
-            // InternalFSM.g:6053:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:6099:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) )
+            // InternalFSM.g:6100:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
             {
-            // InternalFSM.g:6053:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
-            // InternalFSM.g:6054:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            // InternalFSM.g:6100:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:6101:1: ( rule__GuardedTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); 
-            // InternalFSM.g:6055:1: ( rule__GuardedTransition__DocuAssignment_6 )?
-            int alt61=2;
-            int LA61_0 = input.LA(1);
+            // InternalFSM.g:6102:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
 
-            if ( (LA61_0==66) ) {
-                alt61=1;
+            if ( (LA62_0==66) ) {
+                alt62=1;
             }
-            switch (alt61) {
+            switch (alt62) {
                 case 1 :
-                    // InternalFSM.g:6055:2: rule__GuardedTransition__DocuAssignment_6
+                    // InternalFSM.g:6102:2: rule__GuardedTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__DocuAssignment_6();
@@ -17000,14 +17156,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__7"
-    // InternalFSM.g:6065:1: rule__GuardedTransition__Group__7 : rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ;
+    // InternalFSM.g:6112:1: rule__GuardedTransition__Group__7 : rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ;
     public final void rule__GuardedTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6069:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 )
-            // InternalFSM.g:6070:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8
+            // InternalFSM.g:6116:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 )
+            // InternalFSM.g:6117:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8
             {
             pushFollow(FOLLOW_27);
             rule__GuardedTransition__Group__7__Impl();
@@ -17038,17 +17194,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__7__Impl"
-    // InternalFSM.g:6077:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ;
+    // InternalFSM.g:6124:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__GuardedTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6081:1: ( ( '{' ) )
-            // InternalFSM.g:6082:1: ( '{' )
+            // InternalFSM.g:6128:1: ( ( '{' ) )
+            // InternalFSM.g:6129:1: ( '{' )
             {
-            // InternalFSM.g:6082:1: ( '{' )
-            // InternalFSM.g:6083:1: '{'
+            // InternalFSM.g:6129:1: ( '{' )
+            // InternalFSM.g:6130:1: '{'
             {
              before(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,29,FOLLOW_2); 
@@ -17075,14 +17231,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__8"
-    // InternalFSM.g:6096:1: rule__GuardedTransition__Group__8 : rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ;
+    // InternalFSM.g:6143:1: rule__GuardedTransition__Group__8 : rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ;
     public final void rule__GuardedTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6100:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 )
-            // InternalFSM.g:6101:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9
+            // InternalFSM.g:6147:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 )
+            // InternalFSM.g:6148:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9
             {
             pushFollow(FOLLOW_12);
             rule__GuardedTransition__Group__8__Impl();
@@ -17113,17 +17269,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__8__Impl"
-    // InternalFSM.g:6108:1: rule__GuardedTransition__Group__8__Impl : ( 'guard' ) ;
+    // InternalFSM.g:6155:1: rule__GuardedTransition__Group__8__Impl : ( 'guard' ) ;
     public final void rule__GuardedTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6112:1: ( ( 'guard' ) )
-            // InternalFSM.g:6113:1: ( 'guard' )
+            // InternalFSM.g:6159:1: ( ( 'guard' ) )
+            // InternalFSM.g:6160:1: ( 'guard' )
             {
-            // InternalFSM.g:6113:1: ( 'guard' )
-            // InternalFSM.g:6114:1: 'guard'
+            // InternalFSM.g:6160:1: ( 'guard' )
+            // InternalFSM.g:6161:1: 'guard'
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); 
             match(input,49,FOLLOW_2); 
@@ -17150,14 +17306,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__9"
-    // InternalFSM.g:6127:1: rule__GuardedTransition__Group__9 : rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ;
+    // InternalFSM.g:6174:1: rule__GuardedTransition__Group__9 : rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ;
     public final void rule__GuardedTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6131:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 )
-            // InternalFSM.g:6132:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10
+            // InternalFSM.g:6178:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 )
+            // InternalFSM.g:6179:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10
             {
             pushFollow(FOLLOW_22);
             rule__GuardedTransition__Group__9__Impl();
@@ -17188,21 +17344,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__9__Impl"
-    // InternalFSM.g:6139:1: rule__GuardedTransition__Group__9__Impl : ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ;
+    // InternalFSM.g:6186:1: rule__GuardedTransition__Group__9__Impl : ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ;
     public final void rule__GuardedTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6143:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) )
-            // InternalFSM.g:6144:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
+            // InternalFSM.g:6190:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) )
+            // InternalFSM.g:6191:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
             {
-            // InternalFSM.g:6144:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
-            // InternalFSM.g:6145:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalFSM.g:6191:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
+            // InternalFSM.g:6192:1: ( rule__GuardedTransition__GuardAssignment_9 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); 
-            // InternalFSM.g:6146:1: ( rule__GuardedTransition__GuardAssignment_9 )
-            // InternalFSM.g:6146:2: rule__GuardedTransition__GuardAssignment_9
+            // InternalFSM.g:6193:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalFSM.g:6193:2: rule__GuardedTransition__GuardAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__GuardAssignment_9();
@@ -17235,14 +17391,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__10"
-    // InternalFSM.g:6156:1: rule__GuardedTransition__Group__10 : rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ;
+    // InternalFSM.g:6203:1: rule__GuardedTransition__Group__10 : rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ;
     public final void rule__GuardedTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6160:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 )
-            // InternalFSM.g:6161:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11
+            // InternalFSM.g:6207:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 )
+            // InternalFSM.g:6208:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11
             {
             pushFollow(FOLLOW_22);
             rule__GuardedTransition__Group__10__Impl();
@@ -17273,29 +17429,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__10__Impl"
-    // InternalFSM.g:6168:1: rule__GuardedTransition__Group__10__Impl : ( ( rule__GuardedTransition__Group_10__0 )? ) ;
+    // InternalFSM.g:6215:1: rule__GuardedTransition__Group__10__Impl : ( ( rule__GuardedTransition__Group_10__0 )? ) ;
     public final void rule__GuardedTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6172:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) )
-            // InternalFSM.g:6173:1: ( ( rule__GuardedTransition__Group_10__0 )? )
+            // InternalFSM.g:6219:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) )
+            // InternalFSM.g:6220:1: ( ( rule__GuardedTransition__Group_10__0 )? )
             {
-            // InternalFSM.g:6173:1: ( ( rule__GuardedTransition__Group_10__0 )? )
-            // InternalFSM.g:6174:1: ( rule__GuardedTransition__Group_10__0 )?
+            // InternalFSM.g:6220:1: ( ( rule__GuardedTransition__Group_10__0 )? )
+            // InternalFSM.g:6221:1: ( rule__GuardedTransition__Group_10__0 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getGroup_10()); 
-            // InternalFSM.g:6175:1: ( rule__GuardedTransition__Group_10__0 )?
-            int alt62=2;
-            int LA62_0 = input.LA(1);
+            // InternalFSM.g:6222:1: ( rule__GuardedTransition__Group_10__0 )?
+            int alt63=2;
+            int LA63_0 = input.LA(1);
 
-            if ( (LA62_0==46) ) {
-                alt62=1;
+            if ( (LA63_0==46) ) {
+                alt63=1;
             }
-            switch (alt62) {
+            switch (alt63) {
                 case 1 :
-                    // InternalFSM.g:6175:2: rule__GuardedTransition__Group_10__0
+                    // InternalFSM.g:6222:2: rule__GuardedTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__Group_10__0();
@@ -17331,14 +17487,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__11"
-    // InternalFSM.g:6185:1: rule__GuardedTransition__Group__11 : rule__GuardedTransition__Group__11__Impl ;
+    // InternalFSM.g:6232:1: rule__GuardedTransition__Group__11 : rule__GuardedTransition__Group__11__Impl ;
     public final void rule__GuardedTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6189:1: ( rule__GuardedTransition__Group__11__Impl )
-            // InternalFSM.g:6190:2: rule__GuardedTransition__Group__11__Impl
+            // InternalFSM.g:6236:1: ( rule__GuardedTransition__Group__11__Impl )
+            // InternalFSM.g:6237:2: rule__GuardedTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__11__Impl();
@@ -17364,17 +17520,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__11__Impl"
-    // InternalFSM.g:6196:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ;
+    // InternalFSM.g:6243:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ;
     public final void rule__GuardedTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6200:1: ( ( '}' ) )
-            // InternalFSM.g:6201:1: ( '}' )
+            // InternalFSM.g:6247:1: ( ( '}' ) )
+            // InternalFSM.g:6248:1: ( '}' )
             {
-            // InternalFSM.g:6201:1: ( '}' )
-            // InternalFSM.g:6202:1: '}'
+            // InternalFSM.g:6248:1: ( '}' )
+            // InternalFSM.g:6249:1: '}'
             {
              before(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,30,FOLLOW_2); 
@@ -17401,14 +17557,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__0"
-    // InternalFSM.g:6239:1: rule__GuardedTransition__Group_10__0 : rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ;
+    // InternalFSM.g:6286:1: rule__GuardedTransition__Group_10__0 : rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ;
     public final void rule__GuardedTransition__Group_10__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6243:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 )
-            // InternalFSM.g:6244:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1
+            // InternalFSM.g:6290:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 )
+            // InternalFSM.g:6291:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1
             {
             pushFollow(FOLLOW_12);
             rule__GuardedTransition__Group_10__0__Impl();
@@ -17439,17 +17595,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__0__Impl"
-    // InternalFSM.g:6251:1: rule__GuardedTransition__Group_10__0__Impl : ( 'action' ) ;
+    // InternalFSM.g:6298:1: rule__GuardedTransition__Group_10__0__Impl : ( 'action' ) ;
     public final void rule__GuardedTransition__Group_10__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6255:1: ( ( 'action' ) )
-            // InternalFSM.g:6256:1: ( 'action' )
+            // InternalFSM.g:6302:1: ( ( 'action' ) )
+            // InternalFSM.g:6303:1: ( 'action' )
             {
-            // InternalFSM.g:6256:1: ( 'action' )
-            // InternalFSM.g:6257:1: 'action'
+            // InternalFSM.g:6303:1: ( 'action' )
+            // InternalFSM.g:6304:1: 'action'
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); 
             match(input,46,FOLLOW_2); 
@@ -17476,14 +17632,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__1"
-    // InternalFSM.g:6270:1: rule__GuardedTransition__Group_10__1 : rule__GuardedTransition__Group_10__1__Impl ;
+    // InternalFSM.g:6317:1: rule__GuardedTransition__Group_10__1 : rule__GuardedTransition__Group_10__1__Impl ;
     public final void rule__GuardedTransition__Group_10__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6274:1: ( rule__GuardedTransition__Group_10__1__Impl )
-            // InternalFSM.g:6275:2: rule__GuardedTransition__Group_10__1__Impl
+            // InternalFSM.g:6321:1: ( rule__GuardedTransition__Group_10__1__Impl )
+            // InternalFSM.g:6322:2: rule__GuardedTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group_10__1__Impl();
@@ -17509,21 +17665,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__1__Impl"
-    // InternalFSM.g:6281:1: rule__GuardedTransition__Group_10__1__Impl : ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ;
+    // InternalFSM.g:6328:1: rule__GuardedTransition__Group_10__1__Impl : ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ;
     public final void rule__GuardedTransition__Group_10__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6285:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) )
-            // InternalFSM.g:6286:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
+            // InternalFSM.g:6332:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) )
+            // InternalFSM.g:6333:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
             {
-            // InternalFSM.g:6286:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
-            // InternalFSM.g:6287:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
+            // InternalFSM.g:6333:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
+            // InternalFSM.g:6334:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); 
-            // InternalFSM.g:6288:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
-            // InternalFSM.g:6288:2: rule__GuardedTransition__ActionAssignment_10_1
+            // InternalFSM.g:6335:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
+            // InternalFSM.g:6335:2: rule__GuardedTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ActionAssignment_10_1();
@@ -17556,14 +17712,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__0"
-    // InternalFSM.g:6302:1: rule__CPBranchTransition__Group__0 : rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ;
+    // InternalFSM.g:6349:1: rule__CPBranchTransition__Group__0 : rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ;
     public final void rule__CPBranchTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6306:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 )
-            // InternalFSM.g:6307:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1
+            // InternalFSM.g:6353:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 )
+            // InternalFSM.g:6354:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1
             {
             pushFollow(FOLLOW_18);
             rule__CPBranchTransition__Group__0__Impl();
@@ -17594,17 +17750,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__0__Impl"
-    // InternalFSM.g:6314:1: rule__CPBranchTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalFSM.g:6361:1: rule__CPBranchTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__CPBranchTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6318:1: ( ( 'Transition' ) )
-            // InternalFSM.g:6319:1: ( 'Transition' )
+            // InternalFSM.g:6365:1: ( ( 'Transition' ) )
+            // InternalFSM.g:6366:1: ( 'Transition' )
             {
-            // InternalFSM.g:6319:1: ( 'Transition' )
-            // InternalFSM.g:6320:1: 'Transition'
+            // InternalFSM.g:6366:1: ( 'Transition' )
+            // InternalFSM.g:6367:1: 'Transition'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); 
             match(input,42,FOLLOW_2); 
@@ -17631,14 +17787,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__1"
-    // InternalFSM.g:6333:1: rule__CPBranchTransition__Group__1 : rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ;
+    // InternalFSM.g:6380:1: rule__CPBranchTransition__Group__1 : rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ;
     public final void rule__CPBranchTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6337:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 )
-            // InternalFSM.g:6338:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2
+            // InternalFSM.g:6384:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 )
+            // InternalFSM.g:6385:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2
             {
             pushFollow(FOLLOW_18);
             rule__CPBranchTransition__Group__1__Impl();
@@ -17669,29 +17825,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__1__Impl"
-    // InternalFSM.g:6345:1: rule__CPBranchTransition__Group__1__Impl : ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ;
+    // InternalFSM.g:6392:1: rule__CPBranchTransition__Group__1__Impl : ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ;
     public final void rule__CPBranchTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6349:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) )
-            // InternalFSM.g:6350:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
+            // InternalFSM.g:6396:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) )
+            // InternalFSM.g:6397:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
             {
-            // InternalFSM.g:6350:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
-            // InternalFSM.g:6351:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            // InternalFSM.g:6397:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
+            // InternalFSM.g:6398:1: ( rule__CPBranchTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); 
-            // InternalFSM.g:6352:1: ( rule__CPBranchTransition__NameAssignment_1 )?
-            int alt63=2;
-            int LA63_0 = input.LA(1);
+            // InternalFSM.g:6399:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            int alt64=2;
+            int LA64_0 = input.LA(1);
 
-            if ( (LA63_0==RULE_ID) ) {
-                alt63=1;
+            if ( (LA64_0==RULE_ID) ) {
+                alt64=1;
             }
-            switch (alt63) {
+            switch (alt64) {
                 case 1 :
-                    // InternalFSM.g:6352:2: rule__CPBranchTransition__NameAssignment_1
+                    // InternalFSM.g:6399:2: rule__CPBranchTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__NameAssignment_1();
@@ -17727,14 +17883,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__2"
-    // InternalFSM.g:6362:1: rule__CPBranchTransition__Group__2 : rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ;
+    // InternalFSM.g:6409:1: rule__CPBranchTransition__Group__2 : rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ;
     public final void rule__CPBranchTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6366:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 )
-            // InternalFSM.g:6367:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3
+            // InternalFSM.g:6413:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 )
+            // InternalFSM.g:6414:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3
             {
             pushFollow(FOLLOW_21);
             rule__CPBranchTransition__Group__2__Impl();
@@ -17765,17 +17921,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__2__Impl"
-    // InternalFSM.g:6374:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ;
+    // InternalFSM.g:6421:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__CPBranchTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6378:1: ( ( ':' ) )
-            // InternalFSM.g:6379:1: ( ':' )
+            // InternalFSM.g:6425:1: ( ( ':' ) )
+            // InternalFSM.g:6426:1: ( ':' )
             {
-            // InternalFSM.g:6379:1: ( ':' )
-            // InternalFSM.g:6380:1: ':'
+            // InternalFSM.g:6426:1: ( ':' )
+            // InternalFSM.g:6427:1: ':'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2()); 
             match(input,43,FOLLOW_2); 
@@ -17802,14 +17958,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__3"
-    // InternalFSM.g:6393:1: rule__CPBranchTransition__Group__3 : rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ;
+    // InternalFSM.g:6440:1: rule__CPBranchTransition__Group__3 : rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ;
     public final void rule__CPBranchTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6397:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 )
-            // InternalFSM.g:6398:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4
+            // InternalFSM.g:6444:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 )
+            // InternalFSM.g:6445:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4
             {
             pushFollow(FOLLOW_20);
             rule__CPBranchTransition__Group__3__Impl();
@@ -17840,21 +17996,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__3__Impl"
-    // InternalFSM.g:6405:1: rule__CPBranchTransition__Group__3__Impl : ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ;
+    // InternalFSM.g:6452:1: rule__CPBranchTransition__Group__3__Impl : ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ;
     public final void rule__CPBranchTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6409:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) )
-            // InternalFSM.g:6410:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
+            // InternalFSM.g:6456:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) )
+            // InternalFSM.g:6457:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
             {
-            // InternalFSM.g:6410:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
-            // InternalFSM.g:6411:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalFSM.g:6457:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
+            // InternalFSM.g:6458:1: ( rule__CPBranchTransition__FromAssignment_3 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); 
-            // InternalFSM.g:6412:1: ( rule__CPBranchTransition__FromAssignment_3 )
-            // InternalFSM.g:6412:2: rule__CPBranchTransition__FromAssignment_3
+            // InternalFSM.g:6459:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalFSM.g:6459:2: rule__CPBranchTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__FromAssignment_3();
@@ -17887,14 +18043,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__4"
-    // InternalFSM.g:6422:1: rule__CPBranchTransition__Group__4 : rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ;
+    // InternalFSM.g:6469:1: rule__CPBranchTransition__Group__4 : rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ;
     public final void rule__CPBranchTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6426:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 )
-            // InternalFSM.g:6427:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5
+            // InternalFSM.g:6473:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 )
+            // InternalFSM.g:6474:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5
             {
             pushFollow(FOLLOW_21);
             rule__CPBranchTransition__Group__4__Impl();
@@ -17925,17 +18081,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__4__Impl"
-    // InternalFSM.g:6434:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ;
+    // InternalFSM.g:6481:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__CPBranchTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6438:1: ( ( '->' ) )
-            // InternalFSM.g:6439:1: ( '->' )
+            // InternalFSM.g:6485:1: ( ( '->' ) )
+            // InternalFSM.g:6486:1: ( '->' )
             {
-            // InternalFSM.g:6439:1: ( '->' )
-            // InternalFSM.g:6440:1: '->'
+            // InternalFSM.g:6486:1: ( '->' )
+            // InternalFSM.g:6487:1: '->'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -17962,14 +18118,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__5"
-    // InternalFSM.g:6453:1: rule__CPBranchTransition__Group__5 : rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ;
+    // InternalFSM.g:6500:1: rule__CPBranchTransition__Group__5 : rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ;
     public final void rule__CPBranchTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6457:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 )
-            // InternalFSM.g:6458:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6
+            // InternalFSM.g:6504:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 )
+            // InternalFSM.g:6505:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6
             {
             pushFollow(FOLLOW_10);
             rule__CPBranchTransition__Group__5__Impl();
@@ -18000,21 +18156,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__5__Impl"
-    // InternalFSM.g:6465:1: rule__CPBranchTransition__Group__5__Impl : ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ;
+    // InternalFSM.g:6512:1: rule__CPBranchTransition__Group__5__Impl : ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ;
     public final void rule__CPBranchTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6469:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) )
-            // InternalFSM.g:6470:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
+            // InternalFSM.g:6516:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) )
+            // InternalFSM.g:6517:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
             {
-            // InternalFSM.g:6470:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
-            // InternalFSM.g:6471:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalFSM.g:6517:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
+            // InternalFSM.g:6518:1: ( rule__CPBranchTransition__ToAssignment_5 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); 
-            // InternalFSM.g:6472:1: ( rule__CPBranchTransition__ToAssignment_5 )
-            // InternalFSM.g:6472:2: rule__CPBranchTransition__ToAssignment_5
+            // InternalFSM.g:6519:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalFSM.g:6519:2: rule__CPBranchTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ToAssignment_5();
@@ -18047,14 +18203,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__6"
-    // InternalFSM.g:6482:1: rule__CPBranchTransition__Group__6 : rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ;
+    // InternalFSM.g:6529:1: rule__CPBranchTransition__Group__6 : rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ;
     public final void rule__CPBranchTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6486:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 )
-            // InternalFSM.g:6487:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7
+            // InternalFSM.g:6533:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 )
+            // InternalFSM.g:6534:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7
             {
             pushFollow(FOLLOW_10);
             rule__CPBranchTransition__Group__6__Impl();
@@ -18085,29 +18241,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__6__Impl"
-    // InternalFSM.g:6494:1: rule__CPBranchTransition__Group__6__Impl : ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ;
+    // InternalFSM.g:6541:1: rule__CPBranchTransition__Group__6__Impl : ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ;
     public final void rule__CPBranchTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6498:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) )
-            // InternalFSM.g:6499:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:6545:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) )
+            // InternalFSM.g:6546:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
             {
-            // InternalFSM.g:6499:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
-            // InternalFSM.g:6500:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            // InternalFSM.g:6546:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
+            // InternalFSM.g:6547:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); 
-            // InternalFSM.g:6501:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
-            int alt64=2;
-            int LA64_0 = input.LA(1);
+            // InternalFSM.g:6548:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            int alt65=2;
+            int LA65_0 = input.LA(1);
 
-            if ( (LA64_0==66) ) {
-                alt64=1;
+            if ( (LA65_0==66) ) {
+                alt65=1;
             }
-            switch (alt64) {
+            switch (alt65) {
                 case 1 :
-                    // InternalFSM.g:6501:2: rule__CPBranchTransition__DocuAssignment_6
+                    // InternalFSM.g:6548:2: rule__CPBranchTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__DocuAssignment_6();
@@ -18143,14 +18299,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__7"
-    // InternalFSM.g:6511:1: rule__CPBranchTransition__Group__7 : rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ;
+    // InternalFSM.g:6558:1: rule__CPBranchTransition__Group__7 : rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ;
     public final void rule__CPBranchTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6515:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 )
-            // InternalFSM.g:6516:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8
+            // InternalFSM.g:6562:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 )
+            // InternalFSM.g:6563:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8
             {
             pushFollow(FOLLOW_28);
             rule__CPBranchTransition__Group__7__Impl();
@@ -18181,17 +18337,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__7__Impl"
-    // InternalFSM.g:6523:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ;
+    // InternalFSM.g:6570:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__CPBranchTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6527:1: ( ( '{' ) )
-            // InternalFSM.g:6528:1: ( '{' )
+            // InternalFSM.g:6574:1: ( ( '{' ) )
+            // InternalFSM.g:6575:1: ( '{' )
             {
-            // InternalFSM.g:6528:1: ( '{' )
-            // InternalFSM.g:6529:1: '{'
+            // InternalFSM.g:6575:1: ( '{' )
+            // InternalFSM.g:6576:1: '{'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,29,FOLLOW_2); 
@@ -18218,14 +18374,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__8"
-    // InternalFSM.g:6542:1: rule__CPBranchTransition__Group__8 : rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ;
+    // InternalFSM.g:6589:1: rule__CPBranchTransition__Group__8 : rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ;
     public final void rule__CPBranchTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6546:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 )
-            // InternalFSM.g:6547:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9
+            // InternalFSM.g:6593:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 )
+            // InternalFSM.g:6594:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9
             {
             pushFollow(FOLLOW_12);
             rule__CPBranchTransition__Group__8__Impl();
@@ -18256,17 +18412,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__8__Impl"
-    // InternalFSM.g:6554:1: rule__CPBranchTransition__Group__8__Impl : ( 'cond' ) ;
+    // InternalFSM.g:6601:1: rule__CPBranchTransition__Group__8__Impl : ( 'cond' ) ;
     public final void rule__CPBranchTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6558:1: ( ( 'cond' ) )
-            // InternalFSM.g:6559:1: ( 'cond' )
+            // InternalFSM.g:6605:1: ( ( 'cond' ) )
+            // InternalFSM.g:6606:1: ( 'cond' )
             {
-            // InternalFSM.g:6559:1: ( 'cond' )
-            // InternalFSM.g:6560:1: 'cond'
+            // InternalFSM.g:6606:1: ( 'cond' )
+            // InternalFSM.g:6607:1: 'cond'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); 
             match(input,50,FOLLOW_2); 
@@ -18293,14 +18449,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__9"
-    // InternalFSM.g:6573:1: rule__CPBranchTransition__Group__9 : rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ;
+    // InternalFSM.g:6620:1: rule__CPBranchTransition__Group__9 : rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ;
     public final void rule__CPBranchTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6577:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 )
-            // InternalFSM.g:6578:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10
+            // InternalFSM.g:6624:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 )
+            // InternalFSM.g:6625:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10
             {
             pushFollow(FOLLOW_22);
             rule__CPBranchTransition__Group__9__Impl();
@@ -18331,21 +18487,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__9__Impl"
-    // InternalFSM.g:6585:1: rule__CPBranchTransition__Group__9__Impl : ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ;
+    // InternalFSM.g:6632:1: rule__CPBranchTransition__Group__9__Impl : ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ;
     public final void rule__CPBranchTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6589:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) )
-            // InternalFSM.g:6590:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
+            // InternalFSM.g:6636:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) )
+            // InternalFSM.g:6637:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
             {
-            // InternalFSM.g:6590:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
-            // InternalFSM.g:6591:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalFSM.g:6637:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
+            // InternalFSM.g:6638:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); 
-            // InternalFSM.g:6592:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
-            // InternalFSM.g:6592:2: rule__CPBranchTransition__ConditionAssignment_9
+            // InternalFSM.g:6639:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalFSM.g:6639:2: rule__CPBranchTransition__ConditionAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ConditionAssignment_9();
@@ -18378,14 +18534,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__10"
-    // InternalFSM.g:6602:1: rule__CPBranchTransition__Group__10 : rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ;
+    // InternalFSM.g:6649:1: rule__CPBranchTransition__Group__10 : rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ;
     public final void rule__CPBranchTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6606:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 )
-            // InternalFSM.g:6607:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11
+            // InternalFSM.g:6653:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 )
+            // InternalFSM.g:6654:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11
             {
             pushFollow(FOLLOW_22);
             rule__CPBranchTransition__Group__10__Impl();
@@ -18416,29 +18572,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__10__Impl"
-    // InternalFSM.g:6614:1: rule__CPBranchTransition__Group__10__Impl : ( ( rule__CPBranchTransition__Group_10__0 )? ) ;
+    // InternalFSM.g:6661:1: rule__CPBranchTransition__Group__10__Impl : ( ( rule__CPBranchTransition__Group_10__0 )? ) ;
     public final void rule__CPBranchTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6618:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) )
-            // InternalFSM.g:6619:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
+            // InternalFSM.g:6665:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) )
+            // InternalFSM.g:6666:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
             {
-            // InternalFSM.g:6619:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
-            // InternalFSM.g:6620:1: ( rule__CPBranchTransition__Group_10__0 )?
+            // InternalFSM.g:6666:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
+            // InternalFSM.g:6667:1: ( rule__CPBranchTransition__Group_10__0 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); 
-            // InternalFSM.g:6621:1: ( rule__CPBranchTransition__Group_10__0 )?
-            int alt65=2;
-            int LA65_0 = input.LA(1);
+            // InternalFSM.g:6668:1: ( rule__CPBranchTransition__Group_10__0 )?
+            int alt66=2;
+            int LA66_0 = input.LA(1);
 
-            if ( (LA65_0==46) ) {
-                alt65=1;
+            if ( (LA66_0==46) ) {
+                alt66=1;
             }
-            switch (alt65) {
+            switch (alt66) {
                 case 1 :
-                    // InternalFSM.g:6621:2: rule__CPBranchTransition__Group_10__0
+                    // InternalFSM.g:6668:2: rule__CPBranchTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__Group_10__0();
@@ -18474,14 +18630,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__11"
-    // InternalFSM.g:6631:1: rule__CPBranchTransition__Group__11 : rule__CPBranchTransition__Group__11__Impl ;
+    // InternalFSM.g:6678:1: rule__CPBranchTransition__Group__11 : rule__CPBranchTransition__Group__11__Impl ;
     public final void rule__CPBranchTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6635:1: ( rule__CPBranchTransition__Group__11__Impl )
-            // InternalFSM.g:6636:2: rule__CPBranchTransition__Group__11__Impl
+            // InternalFSM.g:6682:1: ( rule__CPBranchTransition__Group__11__Impl )
+            // InternalFSM.g:6683:2: rule__CPBranchTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__11__Impl();
@@ -18507,17 +18663,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__11__Impl"
-    // InternalFSM.g:6642:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ;
+    // InternalFSM.g:6689:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ;
     public final void rule__CPBranchTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6646:1: ( ( '}' ) )
-            // InternalFSM.g:6647:1: ( '}' )
+            // InternalFSM.g:6693:1: ( ( '}' ) )
+            // InternalFSM.g:6694:1: ( '}' )
             {
-            // InternalFSM.g:6647:1: ( '}' )
-            // InternalFSM.g:6648:1: '}'
+            // InternalFSM.g:6694:1: ( '}' )
+            // InternalFSM.g:6695:1: '}'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,30,FOLLOW_2); 
@@ -18544,14 +18700,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__0"
-    // InternalFSM.g:6685:1: rule__CPBranchTransition__Group_10__0 : rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ;
+    // InternalFSM.g:6732:1: rule__CPBranchTransition__Group_10__0 : rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ;
     public final void rule__CPBranchTransition__Group_10__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6689:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 )
-            // InternalFSM.g:6690:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1
+            // InternalFSM.g:6736:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 )
+            // InternalFSM.g:6737:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1
             {
             pushFollow(FOLLOW_12);
             rule__CPBranchTransition__Group_10__0__Impl();
@@ -18582,17 +18738,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__0__Impl"
-    // InternalFSM.g:6697:1: rule__CPBranchTransition__Group_10__0__Impl : ( 'action' ) ;
+    // InternalFSM.g:6744:1: rule__CPBranchTransition__Group_10__0__Impl : ( 'action' ) ;
     public final void rule__CPBranchTransition__Group_10__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6701:1: ( ( 'action' ) )
-            // InternalFSM.g:6702:1: ( 'action' )
+            // InternalFSM.g:6748:1: ( ( 'action' ) )
+            // InternalFSM.g:6749:1: ( 'action' )
             {
-            // InternalFSM.g:6702:1: ( 'action' )
-            // InternalFSM.g:6703:1: 'action'
+            // InternalFSM.g:6749:1: ( 'action' )
+            // InternalFSM.g:6750:1: 'action'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); 
             match(input,46,FOLLOW_2); 
@@ -18619,14 +18775,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__1"
-    // InternalFSM.g:6716:1: rule__CPBranchTransition__Group_10__1 : rule__CPBranchTransition__Group_10__1__Impl ;
+    // InternalFSM.g:6763:1: rule__CPBranchTransition__Group_10__1 : rule__CPBranchTransition__Group_10__1__Impl ;
     public final void rule__CPBranchTransition__Group_10__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6720:1: ( rule__CPBranchTransition__Group_10__1__Impl )
-            // InternalFSM.g:6721:2: rule__CPBranchTransition__Group_10__1__Impl
+            // InternalFSM.g:6767:1: ( rule__CPBranchTransition__Group_10__1__Impl )
+            // InternalFSM.g:6768:2: rule__CPBranchTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group_10__1__Impl();
@@ -18652,21 +18808,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__1__Impl"
-    // InternalFSM.g:6727:1: rule__CPBranchTransition__Group_10__1__Impl : ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ;
+    // InternalFSM.g:6774:1: rule__CPBranchTransition__Group_10__1__Impl : ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ;
     public final void rule__CPBranchTransition__Group_10__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6731:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) )
-            // InternalFSM.g:6732:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
+            // InternalFSM.g:6778:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) )
+            // InternalFSM.g:6779:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
             {
-            // InternalFSM.g:6732:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
-            // InternalFSM.g:6733:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
+            // InternalFSM.g:6779:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
+            // InternalFSM.g:6780:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); 
-            // InternalFSM.g:6734:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
-            // InternalFSM.g:6734:2: rule__CPBranchTransition__ActionAssignment_10_1
+            // InternalFSM.g:6781:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
+            // InternalFSM.g:6781:2: rule__CPBranchTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ActionAssignment_10_1();
@@ -18699,14 +18855,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__0"
-    // InternalFSM.g:6748:1: rule__RefinedTransition__Group__0 : rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ;
+    // InternalFSM.g:6795:1: rule__RefinedTransition__Group__0 : rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ;
     public final void rule__RefinedTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6752:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 )
-            // InternalFSM.g:6753:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1
+            // InternalFSM.g:6799:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 )
+            // InternalFSM.g:6800:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__RefinedTransition__Group__0__Impl();
@@ -18737,17 +18893,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__0__Impl"
-    // InternalFSM.g:6760:1: rule__RefinedTransition__Group__0__Impl : ( 'RefinedTransition' ) ;
+    // InternalFSM.g:6807:1: rule__RefinedTransition__Group__0__Impl : ( 'RefinedTransition' ) ;
     public final void rule__RefinedTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6764:1: ( ( 'RefinedTransition' ) )
-            // InternalFSM.g:6765:1: ( 'RefinedTransition' )
+            // InternalFSM.g:6811:1: ( ( 'RefinedTransition' ) )
+            // InternalFSM.g:6812:1: ( 'RefinedTransition' )
             {
-            // InternalFSM.g:6765:1: ( 'RefinedTransition' )
-            // InternalFSM.g:6766:1: 'RefinedTransition'
+            // InternalFSM.g:6812:1: ( 'RefinedTransition' )
+            // InternalFSM.g:6813:1: 'RefinedTransition'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); 
             match(input,51,FOLLOW_2); 
@@ -18774,14 +18930,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__1"
-    // InternalFSM.g:6779:1: rule__RefinedTransition__Group__1 : rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ;
+    // InternalFSM.g:6826:1: rule__RefinedTransition__Group__1 : rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ;
     public final void rule__RefinedTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6783:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 )
-            // InternalFSM.g:6784:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2
+            // InternalFSM.g:6830:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 )
+            // InternalFSM.g:6831:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2
             {
             pushFollow(FOLLOW_10);
             rule__RefinedTransition__Group__1__Impl();
@@ -18812,21 +18968,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__1__Impl"
-    // InternalFSM.g:6791:1: rule__RefinedTransition__Group__1__Impl : ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ;
+    // InternalFSM.g:6838:1: rule__RefinedTransition__Group__1__Impl : ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ;
     public final void rule__RefinedTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6795:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) )
-            // InternalFSM.g:6796:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
+            // InternalFSM.g:6842:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) )
+            // InternalFSM.g:6843:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
             {
-            // InternalFSM.g:6796:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
-            // InternalFSM.g:6797:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalFSM.g:6843:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
+            // InternalFSM.g:6844:1: ( rule__RefinedTransition__TargetAssignment_1 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); 
-            // InternalFSM.g:6798:1: ( rule__RefinedTransition__TargetAssignment_1 )
-            // InternalFSM.g:6798:2: rule__RefinedTransition__TargetAssignment_1
+            // InternalFSM.g:6845:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalFSM.g:6845:2: rule__RefinedTransition__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__TargetAssignment_1();
@@ -18859,14 +19015,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__2"
-    // InternalFSM.g:6808:1: rule__RefinedTransition__Group__2 : rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ;
+    // InternalFSM.g:6855:1: rule__RefinedTransition__Group__2 : rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ;
     public final void rule__RefinedTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6812:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 )
-            // InternalFSM.g:6813:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3
+            // InternalFSM.g:6859:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 )
+            // InternalFSM.g:6860:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3
             {
             pushFollow(FOLLOW_10);
             rule__RefinedTransition__Group__2__Impl();
@@ -18897,29 +19053,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__2__Impl"
-    // InternalFSM.g:6820:1: rule__RefinedTransition__Group__2__Impl : ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ;
+    // InternalFSM.g:6867:1: rule__RefinedTransition__Group__2__Impl : ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ;
     public final void rule__RefinedTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6824:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) )
-            // InternalFSM.g:6825:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
+            // InternalFSM.g:6871:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) )
+            // InternalFSM.g:6872:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
             {
-            // InternalFSM.g:6825:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
-            // InternalFSM.g:6826:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            // InternalFSM.g:6872:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
+            // InternalFSM.g:6873:1: ( rule__RefinedTransition__DocuAssignment_2 )?
             {
              before(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); 
-            // InternalFSM.g:6827:1: ( rule__RefinedTransition__DocuAssignment_2 )?
-            int alt66=2;
-            int LA66_0 = input.LA(1);
+            // InternalFSM.g:6874:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            int alt67=2;
+            int LA67_0 = input.LA(1);
 
-            if ( (LA66_0==66) ) {
-                alt66=1;
+            if ( (LA67_0==66) ) {
+                alt67=1;
             }
-            switch (alt66) {
+            switch (alt67) {
                 case 1 :
-                    // InternalFSM.g:6827:2: rule__RefinedTransition__DocuAssignment_2
+                    // InternalFSM.g:6874:2: rule__RefinedTransition__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedTransition__DocuAssignment_2();
@@ -18955,14 +19111,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__3"
-    // InternalFSM.g:6837:1: rule__RefinedTransition__Group__3 : rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ;
+    // InternalFSM.g:6884:1: rule__RefinedTransition__Group__3 : rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ;
     public final void rule__RefinedTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6841:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 )
-            // InternalFSM.g:6842:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4
+            // InternalFSM.g:6888:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 )
+            // InternalFSM.g:6889:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4
             {
             pushFollow(FOLLOW_29);
             rule__RefinedTransition__Group__3__Impl();
@@ -18993,17 +19149,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__3__Impl"
-    // InternalFSM.g:6849:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ;
+    // InternalFSM.g:6896:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ;
     public final void rule__RefinedTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6853:1: ( ( '{' ) )
-            // InternalFSM.g:6854:1: ( '{' )
+            // InternalFSM.g:6900:1: ( ( '{' ) )
+            // InternalFSM.g:6901:1: ( '{' )
             {
-            // InternalFSM.g:6854:1: ( '{' )
-            // InternalFSM.g:6855:1: '{'
+            // InternalFSM.g:6901:1: ( '{' )
+            // InternalFSM.g:6902:1: '{'
             {
              before(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,29,FOLLOW_2); 
@@ -19030,14 +19186,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__4"
-    // InternalFSM.g:6868:1: rule__RefinedTransition__Group__4 : rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ;
+    // InternalFSM.g:6915:1: rule__RefinedTransition__Group__4 : rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ;
     public final void rule__RefinedTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6872:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 )
-            // InternalFSM.g:6873:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5
+            // InternalFSM.g:6919:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 )
+            // InternalFSM.g:6920:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5
             {
             pushFollow(FOLLOW_12);
             rule__RefinedTransition__Group__4__Impl();
@@ -19068,17 +19224,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__4__Impl"
-    // InternalFSM.g:6880:1: rule__RefinedTransition__Group__4__Impl : ( 'action' ) ;
+    // InternalFSM.g:6927:1: rule__RefinedTransition__Group__4__Impl : ( 'action' ) ;
     public final void rule__RefinedTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6884:1: ( ( 'action' ) )
-            // InternalFSM.g:6885:1: ( 'action' )
+            // InternalFSM.g:6931:1: ( ( 'action' ) )
+            // InternalFSM.g:6932:1: ( 'action' )
             {
-            // InternalFSM.g:6885:1: ( 'action' )
-            // InternalFSM.g:6886:1: 'action'
+            // InternalFSM.g:6932:1: ( 'action' )
+            // InternalFSM.g:6933:1: 'action'
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); 
             match(input,46,FOLLOW_2); 
@@ -19105,14 +19261,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__5"
-    // InternalFSM.g:6899:1: rule__RefinedTransition__Group__5 : rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ;
+    // InternalFSM.g:6946:1: rule__RefinedTransition__Group__5 : rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ;
     public final void rule__RefinedTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6903:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 )
-            // InternalFSM.g:6904:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6
+            // InternalFSM.g:6950:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 )
+            // InternalFSM.g:6951:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6
             {
             pushFollow(FOLLOW_30);
             rule__RefinedTransition__Group__5__Impl();
@@ -19143,21 +19299,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__5__Impl"
-    // InternalFSM.g:6911:1: rule__RefinedTransition__Group__5__Impl : ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ;
+    // InternalFSM.g:6958:1: rule__RefinedTransition__Group__5__Impl : ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ;
     public final void rule__RefinedTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6915:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) )
-            // InternalFSM.g:6916:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
+            // InternalFSM.g:6962:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) )
+            // InternalFSM.g:6963:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
             {
-            // InternalFSM.g:6916:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
-            // InternalFSM.g:6917:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalFSM.g:6963:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
+            // InternalFSM.g:6964:1: ( rule__RefinedTransition__ActionAssignment_5 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); 
-            // InternalFSM.g:6918:1: ( rule__RefinedTransition__ActionAssignment_5 )
-            // InternalFSM.g:6918:2: rule__RefinedTransition__ActionAssignment_5
+            // InternalFSM.g:6965:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalFSM.g:6965:2: rule__RefinedTransition__ActionAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__ActionAssignment_5();
@@ -19190,14 +19346,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__6"
-    // InternalFSM.g:6928:1: rule__RefinedTransition__Group__6 : rule__RefinedTransition__Group__6__Impl ;
+    // InternalFSM.g:6975:1: rule__RefinedTransition__Group__6 : rule__RefinedTransition__Group__6__Impl ;
     public final void rule__RefinedTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6932:1: ( rule__RefinedTransition__Group__6__Impl )
-            // InternalFSM.g:6933:2: rule__RefinedTransition__Group__6__Impl
+            // InternalFSM.g:6979:1: ( rule__RefinedTransition__Group__6__Impl )
+            // InternalFSM.g:6980:2: rule__RefinedTransition__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__6__Impl();
@@ -19223,17 +19379,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__6__Impl"
-    // InternalFSM.g:6939:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ;
+    // InternalFSM.g:6986:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ;
     public final void rule__RefinedTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6943:1: ( ( '}' ) )
-            // InternalFSM.g:6944:1: ( '}' )
+            // InternalFSM.g:6990:1: ( ( '}' ) )
+            // InternalFSM.g:6991:1: ( '}' )
             {
-            // InternalFSM.g:6944:1: ( '}' )
-            // InternalFSM.g:6945:1: '}'
+            // InternalFSM.g:6991:1: ( '}' )
+            // InternalFSM.g:6992:1: '}'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); 
             match(input,30,FOLLOW_2); 
@@ -19260,14 +19416,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__0"
-    // InternalFSM.g:6972:1: rule__TrPointTerminal__Group__0 : rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ;
+    // InternalFSM.g:7019:1: rule__TrPointTerminal__Group__0 : rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ;
     public final void rule__TrPointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6976:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 )
-            // InternalFSM.g:6977:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1
+            // InternalFSM.g:7023:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 )
+            // InternalFSM.g:7024:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__TrPointTerminal__Group__0__Impl();
@@ -19298,17 +19454,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__0__Impl"
-    // InternalFSM.g:6984:1: rule__TrPointTerminal__Group__0__Impl : ( 'my' ) ;
+    // InternalFSM.g:7031:1: rule__TrPointTerminal__Group__0__Impl : ( 'my' ) ;
     public final void rule__TrPointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:6988:1: ( ( 'my' ) )
-            // InternalFSM.g:6989:1: ( 'my' )
+            // InternalFSM.g:7035:1: ( ( 'my' ) )
+            // InternalFSM.g:7036:1: ( 'my' )
             {
-            // InternalFSM.g:6989:1: ( 'my' )
-            // InternalFSM.g:6990:1: 'my'
+            // InternalFSM.g:7036:1: ( 'my' )
+            // InternalFSM.g:7037:1: 'my'
             {
              before(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); 
             match(input,52,FOLLOW_2); 
@@ -19335,14 +19491,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__1"
-    // InternalFSM.g:7003:1: rule__TrPointTerminal__Group__1 : rule__TrPointTerminal__Group__1__Impl ;
+    // InternalFSM.g:7050:1: rule__TrPointTerminal__Group__1 : rule__TrPointTerminal__Group__1__Impl ;
     public final void rule__TrPointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7007:1: ( rule__TrPointTerminal__Group__1__Impl )
-            // InternalFSM.g:7008:2: rule__TrPointTerminal__Group__1__Impl
+            // InternalFSM.g:7054:1: ( rule__TrPointTerminal__Group__1__Impl )
+            // InternalFSM.g:7055:2: rule__TrPointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__1__Impl();
@@ -19368,21 +19524,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__1__Impl"
-    // InternalFSM.g:7014:1: rule__TrPointTerminal__Group__1__Impl : ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ;
+    // InternalFSM.g:7061:1: rule__TrPointTerminal__Group__1__Impl : ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ;
     public final void rule__TrPointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7018:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) )
-            // InternalFSM.g:7019:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
+            // InternalFSM.g:7065:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) )
+            // InternalFSM.g:7066:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
             {
-            // InternalFSM.g:7019:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
-            // InternalFSM.g:7020:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalFSM.g:7066:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
+            // InternalFSM.g:7067:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); 
-            // InternalFSM.g:7021:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
-            // InternalFSM.g:7021:2: rule__TrPointTerminal__TrPointAssignment_1
+            // InternalFSM.g:7068:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalFSM.g:7068:2: rule__TrPointTerminal__TrPointAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__TrPointAssignment_1();
@@ -19415,14 +19571,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__0"
-    // InternalFSM.g:7035:1: rule__SubStateTrPointTerminal__Group__0 : rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ;
+    // InternalFSM.g:7082:1: rule__SubStateTrPointTerminal__Group__0 : rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ;
     public final void rule__SubStateTrPointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7039:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 )
-            // InternalFSM.g:7040:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1
+            // InternalFSM.g:7086:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 )
+            // InternalFSM.g:7087:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1
             {
             pushFollow(FOLLOW_31);
             rule__SubStateTrPointTerminal__Group__0__Impl();
@@ -19453,21 +19609,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__0__Impl"
-    // InternalFSM.g:7047:1: rule__SubStateTrPointTerminal__Group__0__Impl : ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ;
+    // InternalFSM.g:7094:1: rule__SubStateTrPointTerminal__Group__0__Impl : ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ;
     public final void rule__SubStateTrPointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7051:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) )
-            // InternalFSM.g:7052:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
+            // InternalFSM.g:7098:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) )
+            // InternalFSM.g:7099:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
             {
-            // InternalFSM.g:7052:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
-            // InternalFSM.g:7053:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalFSM.g:7099:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
+            // InternalFSM.g:7100:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); 
-            // InternalFSM.g:7054:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
-            // InternalFSM.g:7054:2: rule__SubStateTrPointTerminal__TrPointAssignment_0
+            // InternalFSM.g:7101:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalFSM.g:7101:2: rule__SubStateTrPointTerminal__TrPointAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__TrPointAssignment_0();
@@ -19500,14 +19656,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__1"
-    // InternalFSM.g:7064:1: rule__SubStateTrPointTerminal__Group__1 : rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ;
+    // InternalFSM.g:7111:1: rule__SubStateTrPointTerminal__Group__1 : rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ;
     public final void rule__SubStateTrPointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7068:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 )
-            // InternalFSM.g:7069:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2
+            // InternalFSM.g:7115:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 )
+            // InternalFSM.g:7116:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__SubStateTrPointTerminal__Group__1__Impl();
@@ -19538,17 +19694,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__1__Impl"
-    // InternalFSM.g:7076:1: rule__SubStateTrPointTerminal__Group__1__Impl : ( 'of' ) ;
+    // InternalFSM.g:7123:1: rule__SubStateTrPointTerminal__Group__1__Impl : ( 'of' ) ;
     public final void rule__SubStateTrPointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7080:1: ( ( 'of' ) )
-            // InternalFSM.g:7081:1: ( 'of' )
+            // InternalFSM.g:7127:1: ( ( 'of' ) )
+            // InternalFSM.g:7128:1: ( 'of' )
             {
-            // InternalFSM.g:7081:1: ( 'of' )
-            // InternalFSM.g:7082:1: 'of'
+            // InternalFSM.g:7128:1: ( 'of' )
+            // InternalFSM.g:7129:1: 'of'
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); 
             match(input,53,FOLLOW_2); 
@@ -19575,14 +19731,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__2"
-    // InternalFSM.g:7095:1: rule__SubStateTrPointTerminal__Group__2 : rule__SubStateTrPointTerminal__Group__2__Impl ;
+    // InternalFSM.g:7142:1: rule__SubStateTrPointTerminal__Group__2 : rule__SubStateTrPointTerminal__Group__2__Impl ;
     public final void rule__SubStateTrPointTerminal__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7099:1: ( rule__SubStateTrPointTerminal__Group__2__Impl )
-            // InternalFSM.g:7100:2: rule__SubStateTrPointTerminal__Group__2__Impl
+            // InternalFSM.g:7146:1: ( rule__SubStateTrPointTerminal__Group__2__Impl )
+            // InternalFSM.g:7147:2: rule__SubStateTrPointTerminal__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__2__Impl();
@@ -19608,21 +19764,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__2__Impl"
-    // InternalFSM.g:7106:1: rule__SubStateTrPointTerminal__Group__2__Impl : ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ;
+    // InternalFSM.g:7153:1: rule__SubStateTrPointTerminal__Group__2__Impl : ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ;
     public final void rule__SubStateTrPointTerminal__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7110:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) )
-            // InternalFSM.g:7111:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
+            // InternalFSM.g:7157:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) )
+            // InternalFSM.g:7158:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
             {
-            // InternalFSM.g:7111:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
-            // InternalFSM.g:7112:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalFSM.g:7158:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
+            // InternalFSM.g:7159:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); 
-            // InternalFSM.g:7113:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
-            // InternalFSM.g:7113:2: rule__SubStateTrPointTerminal__StateAssignment_2
+            // InternalFSM.g:7160:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalFSM.g:7160:2: rule__SubStateTrPointTerminal__StateAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__StateAssignment_2();
@@ -19655,14 +19811,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__0"
-    // InternalFSM.g:7129:1: rule__ChoicepointTerminal__Group__0 : rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ;
+    // InternalFSM.g:7176:1: rule__ChoicepointTerminal__Group__0 : rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ;
     public final void rule__ChoicepointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7133:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 )
-            // InternalFSM.g:7134:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1
+            // InternalFSM.g:7180:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 )
+            // InternalFSM.g:7181:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__ChoicepointTerminal__Group__0__Impl();
@@ -19693,17 +19849,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__0__Impl"
-    // InternalFSM.g:7141:1: rule__ChoicepointTerminal__Group__0__Impl : ( 'cp' ) ;
+    // InternalFSM.g:7188:1: rule__ChoicepointTerminal__Group__0__Impl : ( 'cp' ) ;
     public final void rule__ChoicepointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7145:1: ( ( 'cp' ) )
-            // InternalFSM.g:7146:1: ( 'cp' )
+            // InternalFSM.g:7192:1: ( ( 'cp' ) )
+            // InternalFSM.g:7193:1: ( 'cp' )
             {
-            // InternalFSM.g:7146:1: ( 'cp' )
-            // InternalFSM.g:7147:1: 'cp'
+            // InternalFSM.g:7193:1: ( 'cp' )
+            // InternalFSM.g:7194:1: 'cp'
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); 
             match(input,54,FOLLOW_2); 
@@ -19730,14 +19886,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__1"
-    // InternalFSM.g:7160:1: rule__ChoicepointTerminal__Group__1 : rule__ChoicepointTerminal__Group__1__Impl ;
+    // InternalFSM.g:7207:1: rule__ChoicepointTerminal__Group__1 : rule__ChoicepointTerminal__Group__1__Impl ;
     public final void rule__ChoicepointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7164:1: ( rule__ChoicepointTerminal__Group__1__Impl )
-            // InternalFSM.g:7165:2: rule__ChoicepointTerminal__Group__1__Impl
+            // InternalFSM.g:7211:1: ( rule__ChoicepointTerminal__Group__1__Impl )
+            // InternalFSM.g:7212:2: rule__ChoicepointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__1__Impl();
@@ -19763,21 +19919,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__1__Impl"
-    // InternalFSM.g:7171:1: rule__ChoicepointTerminal__Group__1__Impl : ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ;
+    // InternalFSM.g:7218:1: rule__ChoicepointTerminal__Group__1__Impl : ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ;
     public final void rule__ChoicepointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7175:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) )
-            // InternalFSM.g:7176:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
+            // InternalFSM.g:7222:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) )
+            // InternalFSM.g:7223:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
             {
-            // InternalFSM.g:7176:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
-            // InternalFSM.g:7177:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalFSM.g:7223:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
+            // InternalFSM.g:7224:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); 
-            // InternalFSM.g:7178:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
-            // InternalFSM.g:7178:2: rule__ChoicepointTerminal__CpAssignment_1
+            // InternalFSM.g:7225:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalFSM.g:7225:2: rule__ChoicepointTerminal__CpAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__CpAssignment_1();
@@ -19810,14 +19966,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__0"
-    // InternalFSM.g:7192:1: rule__Trigger__Group__0 : rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ;
+    // InternalFSM.g:7239:1: rule__Trigger__Group__0 : rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ;
     public final void rule__Trigger__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7196:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 )
-            // InternalFSM.g:7197:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1
+            // InternalFSM.g:7243:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 )
+            // InternalFSM.g:7244:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1
             {
             pushFollow(FOLLOW_5);
             rule__Trigger__Group__0__Impl();
@@ -19848,17 +20004,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__0__Impl"
-    // InternalFSM.g:7204:1: rule__Trigger__Group__0__Impl : ( '<' ) ;
+    // InternalFSM.g:7251:1: rule__Trigger__Group__0__Impl : ( '<' ) ;
     public final void rule__Trigger__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7208:1: ( ( '<' ) )
-            // InternalFSM.g:7209:1: ( '<' )
+            // InternalFSM.g:7255:1: ( ( '<' ) )
+            // InternalFSM.g:7256:1: ( '<' )
             {
-            // InternalFSM.g:7209:1: ( '<' )
-            // InternalFSM.g:7210:1: '<'
+            // InternalFSM.g:7256:1: ( '<' )
+            // InternalFSM.g:7257:1: '<'
             {
              before(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); 
             match(input,55,FOLLOW_2); 
@@ -19885,14 +20041,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__1"
-    // InternalFSM.g:7223:1: rule__Trigger__Group__1 : rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ;
+    // InternalFSM.g:7270:1: rule__Trigger__Group__1 : rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ;
     public final void rule__Trigger__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7227:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 )
-            // InternalFSM.g:7228:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2
+            // InternalFSM.g:7274:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 )
+            // InternalFSM.g:7275:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2
             {
             pushFollow(FOLLOW_32);
             rule__Trigger__Group__1__Impl();
@@ -19923,21 +20079,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__1__Impl"
-    // InternalFSM.g:7235:1: rule__Trigger__Group__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ;
+    // InternalFSM.g:7282:1: rule__Trigger__Group__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ;
     public final void rule__Trigger__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7239:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) )
-            // InternalFSM.g:7240:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
+            // InternalFSM.g:7286:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) )
+            // InternalFSM.g:7287:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
             {
-            // InternalFSM.g:7240:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
-            // InternalFSM.g:7241:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalFSM.g:7287:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
+            // InternalFSM.g:7288:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); 
-            // InternalFSM.g:7242:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
-            // InternalFSM.g:7242:2: rule__Trigger__MsgFromIfPairsAssignment_1
+            // InternalFSM.g:7289:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalFSM.g:7289:2: rule__Trigger__MsgFromIfPairsAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_1();
@@ -19970,14 +20126,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__2"
-    // InternalFSM.g:7252:1: rule__Trigger__Group__2 : rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ;
+    // InternalFSM.g:7299:1: rule__Trigger__Group__2 : rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ;
     public final void rule__Trigger__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7256:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 )
-            // InternalFSM.g:7257:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3
+            // InternalFSM.g:7303:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 )
+            // InternalFSM.g:7304:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3
             {
             pushFollow(FOLLOW_32);
             rule__Trigger__Group__2__Impl();
@@ -20008,33 +20164,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__2__Impl"
-    // InternalFSM.g:7264:1: rule__Trigger__Group__2__Impl : ( ( rule__Trigger__Group_2__0 )* ) ;
+    // InternalFSM.g:7311:1: rule__Trigger__Group__2__Impl : ( ( rule__Trigger__Group_2__0 )* ) ;
     public final void rule__Trigger__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7268:1: ( ( ( rule__Trigger__Group_2__0 )* ) )
-            // InternalFSM.g:7269:1: ( ( rule__Trigger__Group_2__0 )* )
+            // InternalFSM.g:7315:1: ( ( ( rule__Trigger__Group_2__0 )* ) )
+            // InternalFSM.g:7316:1: ( ( rule__Trigger__Group_2__0 )* )
             {
-            // InternalFSM.g:7269:1: ( ( rule__Trigger__Group_2__0 )* )
-            // InternalFSM.g:7270:1: ( rule__Trigger__Group_2__0 )*
+            // InternalFSM.g:7316:1: ( ( rule__Trigger__Group_2__0 )* )
+            // InternalFSM.g:7317:1: ( rule__Trigger__Group_2__0 )*
             {
              before(grammarAccess.getTriggerAccess().getGroup_2()); 
-            // InternalFSM.g:7271:1: ( rule__Trigger__Group_2__0 )*
-            loop67:
+            // InternalFSM.g:7318:1: ( rule__Trigger__Group_2__0 )*
+            loop68:
             do {
-                int alt67=2;
-                int LA67_0 = input.LA(1);
+                int alt68=2;
+                int LA68_0 = input.LA(1);
 
-                if ( (LA67_0==57) ) {
-                    alt67=1;
+                if ( (LA68_0==57) ) {
+                    alt68=1;
                 }
 
 
-                switch (alt67) {
+                switch (alt68) {
             	case 1 :
-            	    // InternalFSM.g:7271:2: rule__Trigger__Group_2__0
+            	    // InternalFSM.g:7318:2: rule__Trigger__Group_2__0
             	    {
             	    pushFollow(FOLLOW_33);
             	    rule__Trigger__Group_2__0();
@@ -20046,7 +20202,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop67;
+            	    break loop68;
                 }
             } while (true);
 
@@ -20073,14 +20229,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__3"
-    // InternalFSM.g:7281:1: rule__Trigger__Group__3 : rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ;
+    // InternalFSM.g:7328:1: rule__Trigger__Group__3 : rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ;
     public final void rule__Trigger__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7285:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 )
-            // InternalFSM.g:7286:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4
+            // InternalFSM.g:7332:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 )
+            // InternalFSM.g:7333:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4
             {
             pushFollow(FOLLOW_32);
             rule__Trigger__Group__3__Impl();
@@ -20111,29 +20267,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__3__Impl"
-    // InternalFSM.g:7293:1: rule__Trigger__Group__3__Impl : ( ( rule__Trigger__GuardAssignment_3 )? ) ;
+    // InternalFSM.g:7340:1: rule__Trigger__Group__3__Impl : ( ( rule__Trigger__GuardAssignment_3 )? ) ;
     public final void rule__Trigger__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7297:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) )
-            // InternalFSM.g:7298:1: ( ( rule__Trigger__GuardAssignment_3 )? )
+            // InternalFSM.g:7344:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) )
+            // InternalFSM.g:7345:1: ( ( rule__Trigger__GuardAssignment_3 )? )
             {
-            // InternalFSM.g:7298:1: ( ( rule__Trigger__GuardAssignment_3 )? )
-            // InternalFSM.g:7299:1: ( rule__Trigger__GuardAssignment_3 )?
+            // InternalFSM.g:7345:1: ( ( rule__Trigger__GuardAssignment_3 )? )
+            // InternalFSM.g:7346:1: ( rule__Trigger__GuardAssignment_3 )?
             {
              before(grammarAccess.getTriggerAccess().getGuardAssignment_3()); 
-            // InternalFSM.g:7300:1: ( rule__Trigger__GuardAssignment_3 )?
-            int alt68=2;
-            int LA68_0 = input.LA(1);
+            // InternalFSM.g:7347:1: ( rule__Trigger__GuardAssignment_3 )?
+            int alt69=2;
+            int LA69_0 = input.LA(1);
 
-            if ( (LA68_0==49) ) {
-                alt68=1;
+            if ( (LA69_0==49) ) {
+                alt69=1;
             }
-            switch (alt68) {
+            switch (alt69) {
                 case 1 :
-                    // InternalFSM.g:7300:2: rule__Trigger__GuardAssignment_3
+                    // InternalFSM.g:7347:2: rule__Trigger__GuardAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__Trigger__GuardAssignment_3();
@@ -20169,14 +20325,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__4"
-    // InternalFSM.g:7310:1: rule__Trigger__Group__4 : rule__Trigger__Group__4__Impl ;
+    // InternalFSM.g:7357:1: rule__Trigger__Group__4 : rule__Trigger__Group__4__Impl ;
     public final void rule__Trigger__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7314:1: ( rule__Trigger__Group__4__Impl )
-            // InternalFSM.g:7315:2: rule__Trigger__Group__4__Impl
+            // InternalFSM.g:7361:1: ( rule__Trigger__Group__4__Impl )
+            // InternalFSM.g:7362:2: rule__Trigger__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__4__Impl();
@@ -20202,17 +20358,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__4__Impl"
-    // InternalFSM.g:7321:1: rule__Trigger__Group__4__Impl : ( '>' ) ;
+    // InternalFSM.g:7368:1: rule__Trigger__Group__4__Impl : ( '>' ) ;
     public final void rule__Trigger__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7325:1: ( ( '>' ) )
-            // InternalFSM.g:7326:1: ( '>' )
+            // InternalFSM.g:7372:1: ( ( '>' ) )
+            // InternalFSM.g:7373:1: ( '>' )
             {
-            // InternalFSM.g:7326:1: ( '>' )
-            // InternalFSM.g:7327:1: '>'
+            // InternalFSM.g:7373:1: ( '>' )
+            // InternalFSM.g:7374:1: '>'
             {
              before(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); 
             match(input,56,FOLLOW_2); 
@@ -20239,14 +20395,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__0"
-    // InternalFSM.g:7350:1: rule__Trigger__Group_2__0 : rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ;
+    // InternalFSM.g:7397:1: rule__Trigger__Group_2__0 : rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ;
     public final void rule__Trigger__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7354:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 )
-            // InternalFSM.g:7355:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1
+            // InternalFSM.g:7401:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 )
+            // InternalFSM.g:7402:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1
             {
             pushFollow(FOLLOW_5);
             rule__Trigger__Group_2__0__Impl();
@@ -20277,17 +20433,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__0__Impl"
-    // InternalFSM.g:7362:1: rule__Trigger__Group_2__0__Impl : ( '|' ) ;
+    // InternalFSM.g:7409:1: rule__Trigger__Group_2__0__Impl : ( '|' ) ;
     public final void rule__Trigger__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7366:1: ( ( '|' ) )
-            // InternalFSM.g:7367:1: ( '|' )
+            // InternalFSM.g:7413:1: ( ( '|' ) )
+            // InternalFSM.g:7414:1: ( '|' )
             {
-            // InternalFSM.g:7367:1: ( '|' )
-            // InternalFSM.g:7368:1: '|'
+            // InternalFSM.g:7414:1: ( '|' )
+            // InternalFSM.g:7415:1: '|'
             {
              before(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); 
             match(input,57,FOLLOW_2); 
@@ -20314,14 +20470,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__1"
-    // InternalFSM.g:7381:1: rule__Trigger__Group_2__1 : rule__Trigger__Group_2__1__Impl ;
+    // InternalFSM.g:7428:1: rule__Trigger__Group_2__1 : rule__Trigger__Group_2__1__Impl ;
     public final void rule__Trigger__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7385:1: ( rule__Trigger__Group_2__1__Impl )
-            // InternalFSM.g:7386:2: rule__Trigger__Group_2__1__Impl
+            // InternalFSM.g:7432:1: ( rule__Trigger__Group_2__1__Impl )
+            // InternalFSM.g:7433:2: rule__Trigger__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group_2__1__Impl();
@@ -20347,21 +20503,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__1__Impl"
-    // InternalFSM.g:7392:1: rule__Trigger__Group_2__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ;
+    // InternalFSM.g:7439:1: rule__Trigger__Group_2__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ;
     public final void rule__Trigger__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7396:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) )
-            // InternalFSM.g:7397:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
+            // InternalFSM.g:7443:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) )
+            // InternalFSM.g:7444:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
             {
-            // InternalFSM.g:7397:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
-            // InternalFSM.g:7398:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
+            // InternalFSM.g:7444:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
+            // InternalFSM.g:7445:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); 
-            // InternalFSM.g:7399:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
-            // InternalFSM.g:7399:2: rule__Trigger__MsgFromIfPairsAssignment_2_1
+            // InternalFSM.g:7446:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
+            // InternalFSM.g:7446:2: rule__Trigger__MsgFromIfPairsAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_2_1();
@@ -20394,14 +20550,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__0"
-    // InternalFSM.g:7413:1: rule__MessageFromIf__Group__0 : rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ;
+    // InternalFSM.g:7460:1: rule__MessageFromIf__Group__0 : rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ;
     public final void rule__MessageFromIf__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7417:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 )
-            // InternalFSM.g:7418:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1
+            // InternalFSM.g:7464:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 )
+            // InternalFSM.g:7465:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1
             {
             pushFollow(FOLLOW_34);
             rule__MessageFromIf__Group__0__Impl();
@@ -20432,21 +20588,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__0__Impl"
-    // InternalFSM.g:7425:1: rule__MessageFromIf__Group__0__Impl : ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ;
+    // InternalFSM.g:7472:1: rule__MessageFromIf__Group__0__Impl : ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ;
     public final void rule__MessageFromIf__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7429:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) )
-            // InternalFSM.g:7430:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
+            // InternalFSM.g:7476:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) )
+            // InternalFSM.g:7477:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
             {
-            // InternalFSM.g:7430:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
-            // InternalFSM.g:7431:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalFSM.g:7477:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
+            // InternalFSM.g:7478:1: ( rule__MessageFromIf__MessageAssignment_0 )
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); 
-            // InternalFSM.g:7432:1: ( rule__MessageFromIf__MessageAssignment_0 )
-            // InternalFSM.g:7432:2: rule__MessageFromIf__MessageAssignment_0
+            // InternalFSM.g:7479:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalFSM.g:7479:2: rule__MessageFromIf__MessageAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__MessageAssignment_0();
@@ -20479,14 +20635,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__1"
-    // InternalFSM.g:7442:1: rule__MessageFromIf__Group__1 : rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ;
+    // InternalFSM.g:7489:1: rule__MessageFromIf__Group__1 : rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ;
     public final void rule__MessageFromIf__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7446:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 )
-            // InternalFSM.g:7447:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2
+            // InternalFSM.g:7493:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 )
+            // InternalFSM.g:7494:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__MessageFromIf__Group__1__Impl();
@@ -20517,17 +20673,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__1__Impl"
-    // InternalFSM.g:7454:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ;
+    // InternalFSM.g:7501:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ;
     public final void rule__MessageFromIf__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7458:1: ( ( ':' ) )
-            // InternalFSM.g:7459:1: ( ':' )
+            // InternalFSM.g:7505:1: ( ( ':' ) )
+            // InternalFSM.g:7506:1: ( ':' )
             {
-            // InternalFSM.g:7459:1: ( ':' )
-            // InternalFSM.g:7460:1: ':'
+            // InternalFSM.g:7506:1: ( ':' )
+            // InternalFSM.g:7507:1: ':'
             {
              before(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); 
             match(input,43,FOLLOW_2); 
@@ -20554,14 +20710,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__2"
-    // InternalFSM.g:7473:1: rule__MessageFromIf__Group__2 : rule__MessageFromIf__Group__2__Impl ;
+    // InternalFSM.g:7520:1: rule__MessageFromIf__Group__2 : rule__MessageFromIf__Group__2__Impl ;
     public final void rule__MessageFromIf__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7477:1: ( rule__MessageFromIf__Group__2__Impl )
-            // InternalFSM.g:7478:2: rule__MessageFromIf__Group__2__Impl
+            // InternalFSM.g:7524:1: ( rule__MessageFromIf__Group__2__Impl )
+            // InternalFSM.g:7525:2: rule__MessageFromIf__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__2__Impl();
@@ -20587,21 +20743,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__2__Impl"
-    // InternalFSM.g:7484:1: rule__MessageFromIf__Group__2__Impl : ( ( rule__MessageFromIf__FromAssignment_2 ) ) ;
+    // InternalFSM.g:7531:1: rule__MessageFromIf__Group__2__Impl : ( ( rule__MessageFromIf__FromAssignment_2 ) ) ;
     public final void rule__MessageFromIf__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7488:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) )
-            // InternalFSM.g:7489:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
+            // InternalFSM.g:7535:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) )
+            // InternalFSM.g:7536:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
             {
-            // InternalFSM.g:7489:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
-            // InternalFSM.g:7490:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalFSM.g:7536:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
+            // InternalFSM.g:7537:1: ( rule__MessageFromIf__FromAssignment_2 )
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); 
-            // InternalFSM.g:7491:1: ( rule__MessageFromIf__FromAssignment_2 )
-            // InternalFSM.g:7491:2: rule__MessageFromIf__FromAssignment_2
+            // InternalFSM.g:7538:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalFSM.g:7538:2: rule__MessageFromIf__FromAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__FromAssignment_2();
@@ -20634,14 +20790,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__0"
-    // InternalFSM.g:7507:1: rule__Guard__Group__0 : rule__Guard__Group__0__Impl rule__Guard__Group__1 ;
+    // InternalFSM.g:7554:1: rule__Guard__Group__0 : rule__Guard__Group__0__Impl rule__Guard__Group__1 ;
     public final void rule__Guard__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7511:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 )
-            // InternalFSM.g:7512:2: rule__Guard__Group__0__Impl rule__Guard__Group__1
+            // InternalFSM.g:7558:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 )
+            // InternalFSM.g:7559:2: rule__Guard__Group__0__Impl rule__Guard__Group__1
             {
             pushFollow(FOLLOW_12);
             rule__Guard__Group__0__Impl();
@@ -20672,17 +20828,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__0__Impl"
-    // InternalFSM.g:7519:1: rule__Guard__Group__0__Impl : ( 'guard' ) ;
+    // InternalFSM.g:7566:1: rule__Guard__Group__0__Impl : ( 'guard' ) ;
     public final void rule__Guard__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7523:1: ( ( 'guard' ) )
-            // InternalFSM.g:7524:1: ( 'guard' )
+            // InternalFSM.g:7570:1: ( ( 'guard' ) )
+            // InternalFSM.g:7571:1: ( 'guard' )
             {
-            // InternalFSM.g:7524:1: ( 'guard' )
-            // InternalFSM.g:7525:1: 'guard'
+            // InternalFSM.g:7571:1: ( 'guard' )
+            // InternalFSM.g:7572:1: 'guard'
             {
              before(grammarAccess.getGuardAccess().getGuardKeyword_0()); 
             match(input,49,FOLLOW_2); 
@@ -20709,14 +20865,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__1"
-    // InternalFSM.g:7538:1: rule__Guard__Group__1 : rule__Guard__Group__1__Impl ;
+    // InternalFSM.g:7585:1: rule__Guard__Group__1 : rule__Guard__Group__1__Impl ;
     public final void rule__Guard__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7542:1: ( rule__Guard__Group__1__Impl )
-            // InternalFSM.g:7543:2: rule__Guard__Group__1__Impl
+            // InternalFSM.g:7589:1: ( rule__Guard__Group__1__Impl )
+            // InternalFSM.g:7590:2: rule__Guard__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__1__Impl();
@@ -20742,21 +20898,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__1__Impl"
-    // InternalFSM.g:7549:1: rule__Guard__Group__1__Impl : ( ( rule__Guard__GuardAssignment_1 ) ) ;
+    // InternalFSM.g:7596:1: rule__Guard__Group__1__Impl : ( ( rule__Guard__GuardAssignment_1 ) ) ;
     public final void rule__Guard__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7553:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) )
-            // InternalFSM.g:7554:1: ( ( rule__Guard__GuardAssignment_1 ) )
+            // InternalFSM.g:7600:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) )
+            // InternalFSM.g:7601:1: ( ( rule__Guard__GuardAssignment_1 ) )
             {
-            // InternalFSM.g:7554:1: ( ( rule__Guard__GuardAssignment_1 ) )
-            // InternalFSM.g:7555:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalFSM.g:7601:1: ( ( rule__Guard__GuardAssignment_1 ) )
+            // InternalFSM.g:7602:1: ( rule__Guard__GuardAssignment_1 )
             {
              before(grammarAccess.getGuardAccess().getGuardAssignment_1()); 
-            // InternalFSM.g:7556:1: ( rule__Guard__GuardAssignment_1 )
-            // InternalFSM.g:7556:2: rule__Guard__GuardAssignment_1
+            // InternalFSM.g:7603:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalFSM.g:7603:2: rule__Guard__GuardAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Guard__GuardAssignment_1();
@@ -20789,14 +20945,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__0"
-    // InternalFSM.g:7571:1: rule__InSemanticsRule__Group__0 : rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ;
+    // InternalFSM.g:7618:1: rule__InSemanticsRule__Group__0 : rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ;
     public final void rule__InSemanticsRule__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7575:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 )
-            // InternalFSM.g:7576:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1
+            // InternalFSM.g:7622:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 )
+            // InternalFSM.g:7623:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_34);
             rule__InSemanticsRule__Group__0__Impl();
@@ -20827,17 +20983,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__0__Impl"
-    // InternalFSM.g:7583:1: rule__InSemanticsRule__Group__0__Impl : ( 'in' ) ;
+    // InternalFSM.g:7630:1: rule__InSemanticsRule__Group__0__Impl : ( 'in' ) ;
     public final void rule__InSemanticsRule__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7587:1: ( ( 'in' ) )
-            // InternalFSM.g:7588:1: ( 'in' )
+            // InternalFSM.g:7634:1: ( ( 'in' ) )
+            // InternalFSM.g:7635:1: ( 'in' )
             {
-            // InternalFSM.g:7588:1: ( 'in' )
-            // InternalFSM.g:7589:1: 'in'
+            // InternalFSM.g:7635:1: ( 'in' )
+            // InternalFSM.g:7636:1: 'in'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); 
             match(input,58,FOLLOW_2); 
@@ -20864,14 +21020,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__1"
-    // InternalFSM.g:7602:1: rule__InSemanticsRule__Group__1 : rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ;
+    // InternalFSM.g:7649:1: rule__InSemanticsRule__Group__1 : rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ;
     public final void rule__InSemanticsRule__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7606:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 )
-            // InternalFSM.g:7607:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2
+            // InternalFSM.g:7653:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 )
+            // InternalFSM.g:7654:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__InSemanticsRule__Group__1__Impl();
@@ -20902,17 +21058,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__1__Impl"
-    // InternalFSM.g:7614:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalFSM.g:7661:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ;
     public final void rule__InSemanticsRule__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7618:1: ( ( ':' ) )
-            // InternalFSM.g:7619:1: ( ':' )
+            // InternalFSM.g:7665:1: ( ( ':' ) )
+            // InternalFSM.g:7666:1: ( ':' )
             {
-            // InternalFSM.g:7619:1: ( ':' )
-            // InternalFSM.g:7620:1: ':'
+            // InternalFSM.g:7666:1: ( ':' )
+            // InternalFSM.g:7667:1: ':'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,43,FOLLOW_2); 
@@ -20939,14 +21095,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__2"
-    // InternalFSM.g:7633:1: rule__InSemanticsRule__Group__2 : rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ;
+    // InternalFSM.g:7680:1: rule__InSemanticsRule__Group__2 : rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ;
     public final void rule__InSemanticsRule__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7637:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 )
-            // InternalFSM.g:7638:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3
+            // InternalFSM.g:7684:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 )
+            // InternalFSM.g:7685:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_20);
             rule__InSemanticsRule__Group__2__Impl();
@@ -20977,21 +21133,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__2__Impl"
-    // InternalFSM.g:7645:1: rule__InSemanticsRule__Group__2__Impl : ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ;
+    // InternalFSM.g:7692:1: rule__InSemanticsRule__Group__2__Impl : ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ;
     public final void rule__InSemanticsRule__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7649:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) )
-            // InternalFSM.g:7650:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
+            // InternalFSM.g:7696:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalFSM.g:7697:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalFSM.g:7650:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
-            // InternalFSM.g:7651:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalFSM.g:7697:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
+            // InternalFSM.g:7698:1: ( rule__InSemanticsRule__MsgAssignment_2 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); 
-            // InternalFSM.g:7652:1: ( rule__InSemanticsRule__MsgAssignment_2 )
-            // InternalFSM.g:7652:2: rule__InSemanticsRule__MsgAssignment_2
+            // InternalFSM.g:7699:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalFSM.g:7699:2: rule__InSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__MsgAssignment_2();
@@ -21024,14 +21180,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__3"
-    // InternalFSM.g:7662:1: rule__InSemanticsRule__Group__3 : rule__InSemanticsRule__Group__3__Impl ;
+    // InternalFSM.g:7709:1: rule__InSemanticsRule__Group__3 : rule__InSemanticsRule__Group__3__Impl ;
     public final void rule__InSemanticsRule__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7666:1: ( rule__InSemanticsRule__Group__3__Impl )
-            // InternalFSM.g:7667:2: rule__InSemanticsRule__Group__3__Impl
+            // InternalFSM.g:7713:1: ( rule__InSemanticsRule__Group__3__Impl )
+            // InternalFSM.g:7714:2: rule__InSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__3__Impl();
@@ -21057,29 +21213,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__3__Impl"
-    // InternalFSM.g:7673:1: rule__InSemanticsRule__Group__3__Impl : ( ( rule__InSemanticsRule__Group_3__0 )? ) ;
+    // InternalFSM.g:7720:1: rule__InSemanticsRule__Group__3__Impl : ( ( rule__InSemanticsRule__Group_3__0 )? ) ;
     public final void rule__InSemanticsRule__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7677:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) )
-            // InternalFSM.g:7678:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
+            // InternalFSM.g:7724:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) )
+            // InternalFSM.g:7725:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
             {
-            // InternalFSM.g:7678:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
-            // InternalFSM.g:7679:1: ( rule__InSemanticsRule__Group_3__0 )?
+            // InternalFSM.g:7725:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
+            // InternalFSM.g:7726:1: ( rule__InSemanticsRule__Group_3__0 )?
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); 
-            // InternalFSM.g:7680:1: ( rule__InSemanticsRule__Group_3__0 )?
-            int alt69=2;
-            int LA69_0 = input.LA(1);
+            // InternalFSM.g:7727:1: ( rule__InSemanticsRule__Group_3__0 )?
+            int alt70=2;
+            int LA70_0 = input.LA(1);
 
-            if ( (LA69_0==45) ) {
-                alt69=1;
+            if ( (LA70_0==45) ) {
+                alt70=1;
             }
-            switch (alt69) {
+            switch (alt70) {
                 case 1 :
-                    // InternalFSM.g:7680:2: rule__InSemanticsRule__Group_3__0
+                    // InternalFSM.g:7727:2: rule__InSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3__0();
@@ -21115,14 +21271,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__0"
-    // InternalFSM.g:7698:1: rule__InSemanticsRule__Group_3__0 : rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ;
+    // InternalFSM.g:7745:1: rule__InSemanticsRule__Group_3__0 : rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ;
     public final void rule__InSemanticsRule__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7702:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 )
-            // InternalFSM.g:7703:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1
+            // InternalFSM.g:7749:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 )
+            // InternalFSM.g:7750:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1
             {
             pushFollow(FOLLOW_35);
             rule__InSemanticsRule__Group_3__0__Impl();
@@ -21153,17 +21309,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__0__Impl"
-    // InternalFSM.g:7710:1: rule__InSemanticsRule__Group_3__0__Impl : ( '->' ) ;
+    // InternalFSM.g:7757:1: rule__InSemanticsRule__Group_3__0__Impl : ( '->' ) ;
     public final void rule__InSemanticsRule__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7714:1: ( ( '->' ) )
-            // InternalFSM.g:7715:1: ( '->' )
+            // InternalFSM.g:7761:1: ( ( '->' ) )
+            // InternalFSM.g:7762:1: ( '->' )
             {
-            // InternalFSM.g:7715:1: ( '->' )
-            // InternalFSM.g:7716:1: '->'
+            // InternalFSM.g:7762:1: ( '->' )
+            // InternalFSM.g:7763:1: '->'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,45,FOLLOW_2); 
@@ -21190,14 +21346,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__1"
-    // InternalFSM.g:7729:1: rule__InSemanticsRule__Group_3__1 : rule__InSemanticsRule__Group_3__1__Impl ;
+    // InternalFSM.g:7776:1: rule__InSemanticsRule__Group_3__1 : rule__InSemanticsRule__Group_3__1__Impl ;
     public final void rule__InSemanticsRule__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7733:1: ( rule__InSemanticsRule__Group_3__1__Impl )
-            // InternalFSM.g:7734:2: rule__InSemanticsRule__Group_3__1__Impl
+            // InternalFSM.g:7780:1: ( rule__InSemanticsRule__Group_3__1__Impl )
+            // InternalFSM.g:7781:2: rule__InSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3__1__Impl();
@@ -21223,21 +21379,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__1__Impl"
-    // InternalFSM.g:7740:1: rule__InSemanticsRule__Group_3__1__Impl : ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ;
+    // InternalFSM.g:7787:1: rule__InSemanticsRule__Group_3__1__Impl : ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7744:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) )
-            // InternalFSM.g:7745:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
+            // InternalFSM.g:7791:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalFSM.g:7792:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
             {
-            // InternalFSM.g:7745:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
-            // InternalFSM.g:7746:1: ( rule__InSemanticsRule__Alternatives_3_1 )
+            // InternalFSM.g:7792:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
+            // InternalFSM.g:7793:1: ( rule__InSemanticsRule__Alternatives_3_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); 
-            // InternalFSM.g:7747:1: ( rule__InSemanticsRule__Alternatives_3_1 )
-            // InternalFSM.g:7747:2: rule__InSemanticsRule__Alternatives_3_1
+            // InternalFSM.g:7794:1: ( rule__InSemanticsRule__Alternatives_3_1 )
+            // InternalFSM.g:7794:2: rule__InSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Alternatives_3_1();
@@ -21270,14 +21426,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0"
-    // InternalFSM.g:7761:1: rule__InSemanticsRule__Group_3_1_1__0 : rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ;
+    // InternalFSM.g:7808:1: rule__InSemanticsRule__Group_3_1_1__0 : rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ;
     public final void rule__InSemanticsRule__Group_3_1_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7765:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 )
-            // InternalFSM.g:7766:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1
+            // InternalFSM.g:7812:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 )
+            // InternalFSM.g:7813:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1
             {
             pushFollow(FOLLOW_36);
             rule__InSemanticsRule__Group_3_1_1__0__Impl();
@@ -21308,17 +21464,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0__Impl"
-    // InternalFSM.g:7773:1: rule__InSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
+    // InternalFSM.g:7820:1: rule__InSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7777:1: ( ( '(' ) )
-            // InternalFSM.g:7778:1: ( '(' )
+            // InternalFSM.g:7824:1: ( ( '(' ) )
+            // InternalFSM.g:7825:1: ( '(' )
             {
-            // InternalFSM.g:7778:1: ( '(' )
-            // InternalFSM.g:7779:1: '('
+            // InternalFSM.g:7825:1: ( '(' )
+            // InternalFSM.g:7826:1: '('
             {
              before(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,59,FOLLOW_2); 
@@ -21345,14 +21501,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1"
-    // InternalFSM.g:7792:1: rule__InSemanticsRule__Group_3_1_1__1 : rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ;
+    // InternalFSM.g:7839:1: rule__InSemanticsRule__Group_3_1_1__1 : rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ;
     public final void rule__InSemanticsRule__Group_3_1_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7796:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 )
-            // InternalFSM.g:7797:2: rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2
+            // InternalFSM.g:7843:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 )
+            // InternalFSM.g:7844:2: rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2
             {
             pushFollow(FOLLOW_37);
             rule__InSemanticsRule__Group_3_1_1__1__Impl();
@@ -21383,21 +21539,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1__Impl"
-    // InternalFSM.g:7804:1: rule__InSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
+    // InternalFSM.g:7851:1: rule__InSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7808:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
-            // InternalFSM.g:7809:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalFSM.g:7855:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalFSM.g:7856:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
             {
-            // InternalFSM.g:7809:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
-            // InternalFSM.g:7810:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalFSM.g:7856:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalFSM.g:7857:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); 
-            // InternalFSM.g:7811:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
-            // InternalFSM.g:7811:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
+            // InternalFSM.g:7858:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalFSM.g:7858:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -21430,14 +21586,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2"
-    // InternalFSM.g:7821:1: rule__InSemanticsRule__Group_3_1_1__2 : rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ;
+    // InternalFSM.g:7868:1: rule__InSemanticsRule__Group_3_1_1__2 : rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ;
     public final void rule__InSemanticsRule__Group_3_1_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7825:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 )
-            // InternalFSM.g:7826:2: rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3
+            // InternalFSM.g:7872:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 )
+            // InternalFSM.g:7873:2: rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3
             {
             pushFollow(FOLLOW_38);
             rule__InSemanticsRule__Group_3_1_1__2__Impl();
@@ -21468,24 +21624,24 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2__Impl"
-    // InternalFSM.g:7833:1: rule__InSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
+    // InternalFSM.g:7880:1: rule__InSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7837:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) )
-            // InternalFSM.g:7838:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalFSM.g:7884:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalFSM.g:7885:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
             {
-            // InternalFSM.g:7838:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
-            // InternalFSM.g:7839:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalFSM.g:7885:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalFSM.g:7886:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
             {
-            // InternalFSM.g:7839:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) )
-            // InternalFSM.g:7840:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
+            // InternalFSM.g:7886:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalFSM.g:7887:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalFSM.g:7841:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
-            // InternalFSM.g:7841:2: rule__InSemanticsRule__Group_3_1_1_2__0
+            // InternalFSM.g:7888:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
+            // InternalFSM.g:7888:2: rule__InSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_39);
             rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -21499,24 +21655,24 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             }
 
-            // InternalFSM.g:7844:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
-            // InternalFSM.g:7845:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
+            // InternalFSM.g:7891:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalFSM.g:7892:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalFSM.g:7846:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
-            loop70:
+            // InternalFSM.g:7893:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
+            loop71:
             do {
-                int alt70=2;
-                int LA70_0 = input.LA(1);
+                int alt71=2;
+                int LA71_0 = input.LA(1);
 
-                if ( (LA70_0==61) ) {
-                    alt70=1;
+                if ( (LA71_0==61) ) {
+                    alt71=1;
                 }
 
 
-                switch (alt70) {
+                switch (alt71) {
             	case 1 :
-            	    // InternalFSM.g:7846:2: rule__InSemanticsRule__Group_3_1_1_2__0
+            	    // InternalFSM.g:7893:2: rule__InSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_39);
             	    rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -21528,7 +21684,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop70;
+            	    break loop71;
                 }
             } while (true);
 
@@ -21558,14 +21714,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3"
-    // InternalFSM.g:7857:1: rule__InSemanticsRule__Group_3_1_1__3 : rule__InSemanticsRule__Group_3_1_1__3__Impl ;
+    // InternalFSM.g:7904:1: rule__InSemanticsRule__Group_3_1_1__3 : rule__InSemanticsRule__Group_3_1_1__3__Impl ;
     public final void rule__InSemanticsRule__Group_3_1_1__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7861:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl )
-            // InternalFSM.g:7862:2: rule__InSemanticsRule__Group_3_1_1__3__Impl
+            // InternalFSM.g:7908:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalFSM.g:7909:2: rule__InSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1__3__Impl();
@@ -21591,17 +21747,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3__Impl"
-    // InternalFSM.g:7868:1: rule__InSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
+    // InternalFSM.g:7915:1: rule__InSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7872:1: ( ( ')' ) )
-            // InternalFSM.g:7873:1: ( ')' )
+            // InternalFSM.g:7919:1: ( ( ')' ) )
+            // InternalFSM.g:7920:1: ( ')' )
             {
-            // InternalFSM.g:7873:1: ( ')' )
-            // InternalFSM.g:7874:1: ')'
+            // InternalFSM.g:7920:1: ( ')' )
+            // InternalFSM.g:7921:1: ')'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,60,FOLLOW_2); 
@@ -21628,14 +21784,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0"
-    // InternalFSM.g:7895:1: rule__InSemanticsRule__Group_3_1_1_2__0 : rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ;
+    // InternalFSM.g:7942:1: rule__InSemanticsRule__Group_3_1_1_2__0 : rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7899:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 )
-            // InternalFSM.g:7900:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1
+            // InternalFSM.g:7946:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 )
+            // InternalFSM.g:7947:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1
             {
             pushFollow(FOLLOW_36);
             rule__InSemanticsRule__Group_3_1_1_2__0__Impl();
@@ -21666,17 +21822,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0__Impl"
-    // InternalFSM.g:7907:1: rule__InSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
+    // InternalFSM.g:7954:1: rule__InSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7911:1: ( ( ',' ) )
-            // InternalFSM.g:7912:1: ( ',' )
+            // InternalFSM.g:7958:1: ( ( ',' ) )
+            // InternalFSM.g:7959:1: ( ',' )
             {
-            // InternalFSM.g:7912:1: ( ',' )
-            // InternalFSM.g:7913:1: ','
+            // InternalFSM.g:7959:1: ( ',' )
+            // InternalFSM.g:7960:1: ','
             {
              before(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,61,FOLLOW_2); 
@@ -21703,14 +21859,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1"
-    // InternalFSM.g:7926:1: rule__InSemanticsRule__Group_3_1_1_2__1 : rule__InSemanticsRule__Group_3_1_1_2__1__Impl ;
+    // InternalFSM.g:7973:1: rule__InSemanticsRule__Group_3_1_1_2__1 : rule__InSemanticsRule__Group_3_1_1_2__1__Impl ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7930:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl )
-            // InternalFSM.g:7931:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl
+            // InternalFSM.g:7977:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalFSM.g:7978:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -21736,21 +21892,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1__Impl"
-    // InternalFSM.g:7937:1: rule__InSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
+    // InternalFSM.g:7984:1: rule__InSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7941:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
-            // InternalFSM.g:7942:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalFSM.g:7988:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalFSM.g:7989:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
             {
-            // InternalFSM.g:7942:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
-            // InternalFSM.g:7943:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalFSM.g:7989:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalFSM.g:7990:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); 
-            // InternalFSM.g:7944:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
-            // InternalFSM.g:7944:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
+            // InternalFSM.g:7991:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalFSM.g:7991:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -21783,14 +21939,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__0"
-    // InternalFSM.g:7958:1: rule__OutSemanticsRule__Group__0 : rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ;
+    // InternalFSM.g:8005:1: rule__OutSemanticsRule__Group__0 : rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ;
     public final void rule__OutSemanticsRule__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7962:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 )
-            // InternalFSM.g:7963:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1
+            // InternalFSM.g:8009:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 )
+            // InternalFSM.g:8010:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_34);
             rule__OutSemanticsRule__Group__0__Impl();
@@ -21821,17 +21977,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__0__Impl"
-    // InternalFSM.g:7970:1: rule__OutSemanticsRule__Group__0__Impl : ( 'out' ) ;
+    // InternalFSM.g:8017:1: rule__OutSemanticsRule__Group__0__Impl : ( 'out' ) ;
     public final void rule__OutSemanticsRule__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7974:1: ( ( 'out' ) )
-            // InternalFSM.g:7975:1: ( 'out' )
+            // InternalFSM.g:8021:1: ( ( 'out' ) )
+            // InternalFSM.g:8022:1: ( 'out' )
             {
-            // InternalFSM.g:7975:1: ( 'out' )
-            // InternalFSM.g:7976:1: 'out'
+            // InternalFSM.g:8022:1: ( 'out' )
+            // InternalFSM.g:8023:1: 'out'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); 
             match(input,62,FOLLOW_2); 
@@ -21858,14 +22014,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__1"
-    // InternalFSM.g:7989:1: rule__OutSemanticsRule__Group__1 : rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ;
+    // InternalFSM.g:8036:1: rule__OutSemanticsRule__Group__1 : rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ;
     public final void rule__OutSemanticsRule__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:7993:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 )
-            // InternalFSM.g:7994:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2
+            // InternalFSM.g:8040:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 )
+            // InternalFSM.g:8041:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__OutSemanticsRule__Group__1__Impl();
@@ -21896,17 +22052,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__1__Impl"
-    // InternalFSM.g:8001:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalFSM.g:8048:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ;
     public final void rule__OutSemanticsRule__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8005:1: ( ( ':' ) )
-            // InternalFSM.g:8006:1: ( ':' )
+            // InternalFSM.g:8052:1: ( ( ':' ) )
+            // InternalFSM.g:8053:1: ( ':' )
             {
-            // InternalFSM.g:8006:1: ( ':' )
-            // InternalFSM.g:8007:1: ':'
+            // InternalFSM.g:8053:1: ( ':' )
+            // InternalFSM.g:8054:1: ':'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,43,FOLLOW_2); 
@@ -21933,14 +22089,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__2"
-    // InternalFSM.g:8020:1: rule__OutSemanticsRule__Group__2 : rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ;
+    // InternalFSM.g:8067:1: rule__OutSemanticsRule__Group__2 : rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ;
     public final void rule__OutSemanticsRule__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8024:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 )
-            // InternalFSM.g:8025:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3
+            // InternalFSM.g:8071:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 )
+            // InternalFSM.g:8072:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_20);
             rule__OutSemanticsRule__Group__2__Impl();
@@ -21971,21 +22127,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__2__Impl"
-    // InternalFSM.g:8032:1: rule__OutSemanticsRule__Group__2__Impl : ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ;
+    // InternalFSM.g:8079:1: rule__OutSemanticsRule__Group__2__Impl : ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ;
     public final void rule__OutSemanticsRule__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8036:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) )
-            // InternalFSM.g:8037:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
+            // InternalFSM.g:8083:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalFSM.g:8084:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalFSM.g:8037:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
-            // InternalFSM.g:8038:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalFSM.g:8084:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
+            // InternalFSM.g:8085:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); 
-            // InternalFSM.g:8039:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
-            // InternalFSM.g:8039:2: rule__OutSemanticsRule__MsgAssignment_2
+            // InternalFSM.g:8086:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalFSM.g:8086:2: rule__OutSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__MsgAssignment_2();
@@ -22018,14 +22174,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__3"
-    // InternalFSM.g:8049:1: rule__OutSemanticsRule__Group__3 : rule__OutSemanticsRule__Group__3__Impl ;
+    // InternalFSM.g:8096:1: rule__OutSemanticsRule__Group__3 : rule__OutSemanticsRule__Group__3__Impl ;
     public final void rule__OutSemanticsRule__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8053:1: ( rule__OutSemanticsRule__Group__3__Impl )
-            // InternalFSM.g:8054:2: rule__OutSemanticsRule__Group__3__Impl
+            // InternalFSM.g:8100:1: ( rule__OutSemanticsRule__Group__3__Impl )
+            // InternalFSM.g:8101:2: rule__OutSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__3__Impl();
@@ -22051,29 +22207,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__3__Impl"
-    // InternalFSM.g:8060:1: rule__OutSemanticsRule__Group__3__Impl : ( ( rule__OutSemanticsRule__Group_3__0 )? ) ;
+    // InternalFSM.g:8107:1: rule__OutSemanticsRule__Group__3__Impl : ( ( rule__OutSemanticsRule__Group_3__0 )? ) ;
     public final void rule__OutSemanticsRule__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8064:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) )
-            // InternalFSM.g:8065:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
+            // InternalFSM.g:8111:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) )
+            // InternalFSM.g:8112:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
             {
-            // InternalFSM.g:8065:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
-            // InternalFSM.g:8066:1: ( rule__OutSemanticsRule__Group_3__0 )?
+            // InternalFSM.g:8112:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
+            // InternalFSM.g:8113:1: ( rule__OutSemanticsRule__Group_3__0 )?
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); 
-            // InternalFSM.g:8067:1: ( rule__OutSemanticsRule__Group_3__0 )?
-            int alt71=2;
-            int LA71_0 = input.LA(1);
+            // InternalFSM.g:8114:1: ( rule__OutSemanticsRule__Group_3__0 )?
+            int alt72=2;
+            int LA72_0 = input.LA(1);
 
-            if ( (LA71_0==45) ) {
-                alt71=1;
+            if ( (LA72_0==45) ) {
+                alt72=1;
             }
-            switch (alt71) {
+            switch (alt72) {
                 case 1 :
-                    // InternalFSM.g:8067:2: rule__OutSemanticsRule__Group_3__0
+                    // InternalFSM.g:8114:2: rule__OutSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3__0();
@@ -22109,14 +22265,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__0"
-    // InternalFSM.g:8085:1: rule__OutSemanticsRule__Group_3__0 : rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ;
+    // InternalFSM.g:8132:1: rule__OutSemanticsRule__Group_3__0 : rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ;
     public final void rule__OutSemanticsRule__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8089:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 )
-            // InternalFSM.g:8090:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1
+            // InternalFSM.g:8136:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 )
+            // InternalFSM.g:8137:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1
             {
             pushFollow(FOLLOW_35);
             rule__OutSemanticsRule__Group_3__0__Impl();
@@ -22147,17 +22303,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__0__Impl"
-    // InternalFSM.g:8097:1: rule__OutSemanticsRule__Group_3__0__Impl : ( '->' ) ;
+    // InternalFSM.g:8144:1: rule__OutSemanticsRule__Group_3__0__Impl : ( '->' ) ;
     public final void rule__OutSemanticsRule__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8101:1: ( ( '->' ) )
-            // InternalFSM.g:8102:1: ( '->' )
+            // InternalFSM.g:8148:1: ( ( '->' ) )
+            // InternalFSM.g:8149:1: ( '->' )
             {
-            // InternalFSM.g:8102:1: ( '->' )
-            // InternalFSM.g:8103:1: '->'
+            // InternalFSM.g:8149:1: ( '->' )
+            // InternalFSM.g:8150:1: '->'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,45,FOLLOW_2); 
@@ -22184,14 +22340,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__1"
-    // InternalFSM.g:8116:1: rule__OutSemanticsRule__Group_3__1 : rule__OutSemanticsRule__Group_3__1__Impl ;
+    // InternalFSM.g:8163:1: rule__OutSemanticsRule__Group_3__1 : rule__OutSemanticsRule__Group_3__1__Impl ;
     public final void rule__OutSemanticsRule__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8120:1: ( rule__OutSemanticsRule__Group_3__1__Impl )
-            // InternalFSM.g:8121:2: rule__OutSemanticsRule__Group_3__1__Impl
+            // InternalFSM.g:8167:1: ( rule__OutSemanticsRule__Group_3__1__Impl )
+            // InternalFSM.g:8168:2: rule__OutSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3__1__Impl();
@@ -22217,21 +22373,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__1__Impl"
-    // InternalFSM.g:8127:1: rule__OutSemanticsRule__Group_3__1__Impl : ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ;
+    // InternalFSM.g:8174:1: rule__OutSemanticsRule__Group_3__1__Impl : ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8131:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) )
-            // InternalFSM.g:8132:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
+            // InternalFSM.g:8178:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalFSM.g:8179:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
             {
-            // InternalFSM.g:8132:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
-            // InternalFSM.g:8133:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
+            // InternalFSM.g:8179:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
+            // InternalFSM.g:8180:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); 
-            // InternalFSM.g:8134:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
-            // InternalFSM.g:8134:2: rule__OutSemanticsRule__Alternatives_3_1
+            // InternalFSM.g:8181:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
+            // InternalFSM.g:8181:2: rule__OutSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Alternatives_3_1();
@@ -22264,14 +22420,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0"
-    // InternalFSM.g:8148:1: rule__OutSemanticsRule__Group_3_1_1__0 : rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ;
+    // InternalFSM.g:8195:1: rule__OutSemanticsRule__Group_3_1_1__0 : rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8152:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 )
-            // InternalFSM.g:8153:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1
+            // InternalFSM.g:8199:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 )
+            // InternalFSM.g:8200:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1
             {
             pushFollow(FOLLOW_36);
             rule__OutSemanticsRule__Group_3_1_1__0__Impl();
@@ -22302,17 +22458,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0__Impl"
-    // InternalFSM.g:8160:1: rule__OutSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
+    // InternalFSM.g:8207:1: rule__OutSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8164:1: ( ( '(' ) )
-            // InternalFSM.g:8165:1: ( '(' )
+            // InternalFSM.g:8211:1: ( ( '(' ) )
+            // InternalFSM.g:8212:1: ( '(' )
             {
-            // InternalFSM.g:8165:1: ( '(' )
-            // InternalFSM.g:8166:1: '('
+            // InternalFSM.g:8212:1: ( '(' )
+            // InternalFSM.g:8213:1: '('
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,59,FOLLOW_2); 
@@ -22339,14 +22495,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1"
-    // InternalFSM.g:8179:1: rule__OutSemanticsRule__Group_3_1_1__1 : rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ;
+    // InternalFSM.g:8226:1: rule__OutSemanticsRule__Group_3_1_1__1 : rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8183:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 )
-            // InternalFSM.g:8184:2: rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2
+            // InternalFSM.g:8230:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 )
+            // InternalFSM.g:8231:2: rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2
             {
             pushFollow(FOLLOW_37);
             rule__OutSemanticsRule__Group_3_1_1__1__Impl();
@@ -22377,21 +22533,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1__Impl"
-    // InternalFSM.g:8191:1: rule__OutSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
+    // InternalFSM.g:8238:1: rule__OutSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8195:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
-            // InternalFSM.g:8196:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalFSM.g:8242:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalFSM.g:8243:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
             {
-            // InternalFSM.g:8196:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
-            // InternalFSM.g:8197:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalFSM.g:8243:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalFSM.g:8244:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); 
-            // InternalFSM.g:8198:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
-            // InternalFSM.g:8198:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
+            // InternalFSM.g:8245:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalFSM.g:8245:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -22424,14 +22580,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2"
-    // InternalFSM.g:8208:1: rule__OutSemanticsRule__Group_3_1_1__2 : rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ;
+    // InternalFSM.g:8255:1: rule__OutSemanticsRule__Group_3_1_1__2 : rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8212:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 )
-            // InternalFSM.g:8213:2: rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3
+            // InternalFSM.g:8259:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 )
+            // InternalFSM.g:8260:2: rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3
             {
             pushFollow(FOLLOW_38);
             rule__OutSemanticsRule__Group_3_1_1__2__Impl();
@@ -22462,24 +22618,24 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2__Impl"
-    // InternalFSM.g:8220:1: rule__OutSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
+    // InternalFSM.g:8267:1: rule__OutSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8224:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) )
-            // InternalFSM.g:8225:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalFSM.g:8271:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalFSM.g:8272:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
             {
-            // InternalFSM.g:8225:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
-            // InternalFSM.g:8226:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalFSM.g:8272:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalFSM.g:8273:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
             {
-            // InternalFSM.g:8226:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) )
-            // InternalFSM.g:8227:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
+            // InternalFSM.g:8273:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalFSM.g:8274:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalFSM.g:8228:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
-            // InternalFSM.g:8228:2: rule__OutSemanticsRule__Group_3_1_1_2__0
+            // InternalFSM.g:8275:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
+            // InternalFSM.g:8275:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_39);
             rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -22493,24 +22649,24 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
             }
 
-            // InternalFSM.g:8231:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
-            // InternalFSM.g:8232:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
+            // InternalFSM.g:8278:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalFSM.g:8279:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalFSM.g:8233:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
-            loop72:
+            // InternalFSM.g:8280:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
+            loop73:
             do {
-                int alt72=2;
-                int LA72_0 = input.LA(1);
+                int alt73=2;
+                int LA73_0 = input.LA(1);
 
-                if ( (LA72_0==61) ) {
-                    alt72=1;
+                if ( (LA73_0==61) ) {
+                    alt73=1;
                 }
 
 
-                switch (alt72) {
+                switch (alt73) {
             	case 1 :
-            	    // InternalFSM.g:8233:2: rule__OutSemanticsRule__Group_3_1_1_2__0
+            	    // InternalFSM.g:8280:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_39);
             	    rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -22522,7 +22678,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop72;
+            	    break loop73;
                 }
             } while (true);
 
@@ -22552,14 +22708,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3"
-    // InternalFSM.g:8244:1: rule__OutSemanticsRule__Group_3_1_1__3 : rule__OutSemanticsRule__Group_3_1_1__3__Impl ;
+    // InternalFSM.g:8291:1: rule__OutSemanticsRule__Group_3_1_1__3 : rule__OutSemanticsRule__Group_3_1_1__3__Impl ;
     public final void rule__OutSemanticsRule__Group_3_1_1__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8248:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl )
-            // InternalFSM.g:8249:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl
+            // InternalFSM.g:8295:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalFSM.g:8296:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1__3__Impl();
@@ -22585,17 +22741,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3__Impl"
-    // InternalFSM.g:8255:1: rule__OutSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
+    // InternalFSM.g:8302:1: rule__OutSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8259:1: ( ( ')' ) )
-            // InternalFSM.g:8260:1: ( ')' )
+            // InternalFSM.g:8306:1: ( ( ')' ) )
+            // InternalFSM.g:8307:1: ( ')' )
             {
-            // InternalFSM.g:8260:1: ( ')' )
-            // InternalFSM.g:8261:1: ')'
+            // InternalFSM.g:8307:1: ( ')' )
+            // InternalFSM.g:8308:1: ')'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,60,FOLLOW_2); 
@@ -22622,14 +22778,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0"
-    // InternalFSM.g:8282:1: rule__OutSemanticsRule__Group_3_1_1_2__0 : rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ;
+    // InternalFSM.g:8329:1: rule__OutSemanticsRule__Group_3_1_1_2__0 : rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8286:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 )
-            // InternalFSM.g:8287:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1
+            // InternalFSM.g:8333:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 )
+            // InternalFSM.g:8334:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1
             {
             pushFollow(FOLLOW_36);
             rule__OutSemanticsRule__Group_3_1_1_2__0__Impl();
@@ -22660,17 +22816,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0__Impl"
-    // InternalFSM.g:8294:1: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
+    // InternalFSM.g:8341:1: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8298:1: ( ( ',' ) )
-            // InternalFSM.g:8299:1: ( ',' )
+            // InternalFSM.g:8345:1: ( ( ',' ) )
+            // InternalFSM.g:8346:1: ( ',' )
             {
-            // InternalFSM.g:8299:1: ( ',' )
-            // InternalFSM.g:8300:1: ','
+            // InternalFSM.g:8346:1: ( ',' )
+            // InternalFSM.g:8347:1: ','
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,61,FOLLOW_2); 
@@ -22697,14 +22853,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1"
-    // InternalFSM.g:8313:1: rule__OutSemanticsRule__Group_3_1_1_2__1 : rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ;
+    // InternalFSM.g:8360:1: rule__OutSemanticsRule__Group_3_1_1_2__1 : rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8317:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl )
-            // InternalFSM.g:8318:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
+            // InternalFSM.g:8364:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalFSM.g:8365:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -22730,21 +22886,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1__Impl"
-    // InternalFSM.g:8324:1: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
+    // InternalFSM.g:8371:1: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8328:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
-            // InternalFSM.g:8329:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalFSM.g:8375:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalFSM.g:8376:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
             {
-            // InternalFSM.g:8329:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
-            // InternalFSM.g:8330:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalFSM.g:8376:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalFSM.g:8377:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); 
-            // InternalFSM.g:8331:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
-            // InternalFSM.g:8331:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
+            // InternalFSM.g:8378:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalFSM.g:8378:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -22777,14 +22933,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__0"
-    // InternalFSM.g:8348:1: rule__KeyValue__Group__0 : rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ;
+    // InternalFSM.g:8395:1: rule__KeyValue__Group__0 : rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ;
     public final void rule__KeyValue__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8352:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 )
-            // InternalFSM.g:8353:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1
+            // InternalFSM.g:8399:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 )
+            // InternalFSM.g:8400:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1
             {
             pushFollow(FOLLOW_40);
             rule__KeyValue__Group__0__Impl();
@@ -22815,21 +22971,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__0__Impl"
-    // InternalFSM.g:8360:1: rule__KeyValue__Group__0__Impl : ( ( rule__KeyValue__KeyAssignment_0 ) ) ;
+    // InternalFSM.g:8407:1: rule__KeyValue__Group__0__Impl : ( ( rule__KeyValue__KeyAssignment_0 ) ) ;
     public final void rule__KeyValue__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8364:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) )
-            // InternalFSM.g:8365:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
+            // InternalFSM.g:8411:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) )
+            // InternalFSM.g:8412:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
             {
-            // InternalFSM.g:8365:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
-            // InternalFSM.g:8366:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalFSM.g:8412:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
+            // InternalFSM.g:8413:1: ( rule__KeyValue__KeyAssignment_0 )
             {
              before(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); 
-            // InternalFSM.g:8367:1: ( rule__KeyValue__KeyAssignment_0 )
-            // InternalFSM.g:8367:2: rule__KeyValue__KeyAssignment_0
+            // InternalFSM.g:8414:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalFSM.g:8414:2: rule__KeyValue__KeyAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__KeyAssignment_0();
@@ -22862,14 +23018,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__1"
-    // InternalFSM.g:8377:1: rule__KeyValue__Group__1 : rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ;
+    // InternalFSM.g:8424:1: rule__KeyValue__Group__1 : rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ;
     public final void rule__KeyValue__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8381:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 )
-            // InternalFSM.g:8382:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2
+            // InternalFSM.g:8428:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 )
+            // InternalFSM.g:8429:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2
             {
             pushFollow(FOLLOW_41);
             rule__KeyValue__Group__1__Impl();
@@ -22900,17 +23056,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__1__Impl"
-    // InternalFSM.g:8389:1: rule__KeyValue__Group__1__Impl : ( '=' ) ;
+    // InternalFSM.g:8436:1: rule__KeyValue__Group__1__Impl : ( '=' ) ;
     public final void rule__KeyValue__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8393:1: ( ( '=' ) )
-            // InternalFSM.g:8394:1: ( '=' )
+            // InternalFSM.g:8440:1: ( ( '=' ) )
+            // InternalFSM.g:8441:1: ( '=' )
             {
-            // InternalFSM.g:8394:1: ( '=' )
-            // InternalFSM.g:8395:1: '='
+            // InternalFSM.g:8441:1: ( '=' )
+            // InternalFSM.g:8442:1: '='
             {
              before(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); 
             match(input,63,FOLLOW_2); 
@@ -22937,14 +23093,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__2"
-    // InternalFSM.g:8408:1: rule__KeyValue__Group__2 : rule__KeyValue__Group__2__Impl ;
+    // InternalFSM.g:8455:1: rule__KeyValue__Group__2 : rule__KeyValue__Group__2__Impl ;
     public final void rule__KeyValue__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8412:1: ( rule__KeyValue__Group__2__Impl )
-            // InternalFSM.g:8413:2: rule__KeyValue__Group__2__Impl
+            // InternalFSM.g:8459:1: ( rule__KeyValue__Group__2__Impl )
+            // InternalFSM.g:8460:2: rule__KeyValue__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__2__Impl();
@@ -22970,21 +23126,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__2__Impl"
-    // InternalFSM.g:8419:1: rule__KeyValue__Group__2__Impl : ( ( rule__KeyValue__ValueAssignment_2 ) ) ;
+    // InternalFSM.g:8466:1: rule__KeyValue__Group__2__Impl : ( ( rule__KeyValue__ValueAssignment_2 ) ) ;
     public final void rule__KeyValue__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8423:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) )
-            // InternalFSM.g:8424:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
+            // InternalFSM.g:8470:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) )
+            // InternalFSM.g:8471:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
             {
-            // InternalFSM.g:8424:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
-            // InternalFSM.g:8425:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalFSM.g:8471:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
+            // InternalFSM.g:8472:1: ( rule__KeyValue__ValueAssignment_2 )
             {
              before(grammarAccess.getKeyValueAccess().getValueAssignment_2()); 
-            // InternalFSM.g:8426:1: ( rule__KeyValue__ValueAssignment_2 )
-            // InternalFSM.g:8426:2: rule__KeyValue__ValueAssignment_2
+            // InternalFSM.g:8473:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalFSM.g:8473:2: rule__KeyValue__ValueAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__ValueAssignment_2();
@@ -23017,14 +23173,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0"
-    // InternalFSM.g:8445:1: rule__SimpleAnnotationAttribute__Group__0 : rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ;
+    // InternalFSM.g:8492:1: rule__SimpleAnnotationAttribute__Group__0 : rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ;
     public final void rule__SimpleAnnotationAttribute__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8449:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 )
-            // InternalFSM.g:8450:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1
+            // InternalFSM.g:8496:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 )
+            // InternalFSM.g:8497:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1
             {
             pushFollow(FOLLOW_42);
             rule__SimpleAnnotationAttribute__Group__0__Impl();
@@ -23055,21 +23211,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0__Impl"
-    // InternalFSM.g:8457:1: rule__SimpleAnnotationAttribute__Group__0__Impl : ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ;
+    // InternalFSM.g:8504:1: rule__SimpleAnnotationAttribute__Group__0__Impl : ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8461:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) )
-            // InternalFSM.g:8462:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
+            // InternalFSM.g:8508:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalFSM.g:8509:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalFSM.g:8462:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
-            // InternalFSM.g:8463:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalFSM.g:8509:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
+            // InternalFSM.g:8510:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); 
-            // InternalFSM.g:8464:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
-            // InternalFSM.g:8464:2: rule__SimpleAnnotationAttribute__Alternatives_0
+            // InternalFSM.g:8511:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalFSM.g:8511:2: rule__SimpleAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Alternatives_0();
@@ -23102,14 +23258,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1"
-    // InternalFSM.g:8474:1: rule__SimpleAnnotationAttribute__Group__1 : rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ;
+    // InternalFSM.g:8521:1: rule__SimpleAnnotationAttribute__Group__1 : rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ;
     public final void rule__SimpleAnnotationAttribute__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8478:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 )
-            // InternalFSM.g:8479:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2
+            // InternalFSM.g:8525:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 )
+            // InternalFSM.g:8526:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__SimpleAnnotationAttribute__Group__1__Impl();
@@ -23140,17 +23296,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1__Impl"
-    // InternalFSM.g:8486:1: rule__SimpleAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
+    // InternalFSM.g:8533:1: rule__SimpleAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
     public final void rule__SimpleAnnotationAttribute__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8490:1: ( ( 'attribute' ) )
-            // InternalFSM.g:8491:1: ( 'attribute' )
+            // InternalFSM.g:8537:1: ( ( 'attribute' ) )
+            // InternalFSM.g:8538:1: ( 'attribute' )
             {
-            // InternalFSM.g:8491:1: ( 'attribute' )
-            // InternalFSM.g:8492:1: 'attribute'
+            // InternalFSM.g:8538:1: ( 'attribute' )
+            // InternalFSM.g:8539:1: 'attribute'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,64,FOLLOW_2); 
@@ -23177,14 +23333,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2"
-    // InternalFSM.g:8505:1: rule__SimpleAnnotationAttribute__Group__2 : rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ;
+    // InternalFSM.g:8552:1: rule__SimpleAnnotationAttribute__Group__2 : rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ;
     public final void rule__SimpleAnnotationAttribute__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8509:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 )
-            // InternalFSM.g:8510:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3
+            // InternalFSM.g:8556:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 )
+            // InternalFSM.g:8557:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_34);
             rule__SimpleAnnotationAttribute__Group__2__Impl();
@@ -23215,21 +23371,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2__Impl"
-    // InternalFSM.g:8517:1: rule__SimpleAnnotationAttribute__Group__2__Impl : ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ;
+    // InternalFSM.g:8564:1: rule__SimpleAnnotationAttribute__Group__2__Impl : ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8521:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) )
-            // InternalFSM.g:8522:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
+            // InternalFSM.g:8568:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalFSM.g:8569:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalFSM.g:8522:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
-            // InternalFSM.g:8523:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalFSM.g:8569:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
+            // InternalFSM.g:8570:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); 
-            // InternalFSM.g:8524:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
-            // InternalFSM.g:8524:2: rule__SimpleAnnotationAttribute__NameAssignment_2
+            // InternalFSM.g:8571:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalFSM.g:8571:2: rule__SimpleAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__NameAssignment_2();
@@ -23262,14 +23418,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3"
-    // InternalFSM.g:8534:1: rule__SimpleAnnotationAttribute__Group__3 : rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ;
+    // InternalFSM.g:8581:1: rule__SimpleAnnotationAttribute__Group__3 : rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ;
     public final void rule__SimpleAnnotationAttribute__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8538:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 )
-            // InternalFSM.g:8539:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4
+            // InternalFSM.g:8585:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 )
+            // InternalFSM.g:8586:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_43);
             rule__SimpleAnnotationAttribute__Group__3__Impl();
@@ -23300,17 +23456,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3__Impl"
-    // InternalFSM.g:8546:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalFSM.g:8593:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ;
     public final void rule__SimpleAnnotationAttribute__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8550:1: ( ( ':' ) )
-            // InternalFSM.g:8551:1: ( ':' )
+            // InternalFSM.g:8597:1: ( ( ':' ) )
+            // InternalFSM.g:8598:1: ( ':' )
             {
-            // InternalFSM.g:8551:1: ( ':' )
-            // InternalFSM.g:8552:1: ':'
+            // InternalFSM.g:8598:1: ( ':' )
+            // InternalFSM.g:8599:1: ':'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,43,FOLLOW_2); 
@@ -23337,14 +23493,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4"
-    // InternalFSM.g:8565:1: rule__SimpleAnnotationAttribute__Group__4 : rule__SimpleAnnotationAttribute__Group__4__Impl ;
+    // InternalFSM.g:8612:1: rule__SimpleAnnotationAttribute__Group__4 : rule__SimpleAnnotationAttribute__Group__4__Impl ;
     public final void rule__SimpleAnnotationAttribute__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8569:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl )
-            // InternalFSM.g:8570:2: rule__SimpleAnnotationAttribute__Group__4__Impl
+            // InternalFSM.g:8616:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl )
+            // InternalFSM.g:8617:2: rule__SimpleAnnotationAttribute__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__4__Impl();
@@ -23370,21 +23526,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4__Impl"
-    // InternalFSM.g:8576:1: rule__SimpleAnnotationAttribute__Group__4__Impl : ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ;
+    // InternalFSM.g:8623:1: rule__SimpleAnnotationAttribute__Group__4__Impl : ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8580:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) )
-            // InternalFSM.g:8581:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
+            // InternalFSM.g:8627:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) )
+            // InternalFSM.g:8628:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
             {
-            // InternalFSM.g:8581:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
-            // InternalFSM.g:8582:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalFSM.g:8628:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
+            // InternalFSM.g:8629:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); 
-            // InternalFSM.g:8583:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
-            // InternalFSM.g:8583:2: rule__SimpleAnnotationAttribute__TypeAssignment_4
+            // InternalFSM.g:8630:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalFSM.g:8630:2: rule__SimpleAnnotationAttribute__TypeAssignment_4
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__TypeAssignment_4();
@@ -23417,14 +23573,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__0"
-    // InternalFSM.g:8603:1: rule__EnumAnnotationAttribute__Group__0 : rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ;
+    // InternalFSM.g:8650:1: rule__EnumAnnotationAttribute__Group__0 : rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ;
     public final void rule__EnumAnnotationAttribute__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8607:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 )
-            // InternalFSM.g:8608:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1
+            // InternalFSM.g:8654:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 )
+            // InternalFSM.g:8655:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1
             {
             pushFollow(FOLLOW_42);
             rule__EnumAnnotationAttribute__Group__0__Impl();
@@ -23455,21 +23611,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__0__Impl"
-    // InternalFSM.g:8615:1: rule__EnumAnnotationAttribute__Group__0__Impl : ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ;
+    // InternalFSM.g:8662:1: rule__EnumAnnotationAttribute__Group__0__Impl : ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8619:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) )
-            // InternalFSM.g:8620:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
+            // InternalFSM.g:8666:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalFSM.g:8667:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalFSM.g:8620:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
-            // InternalFSM.g:8621:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalFSM.g:8667:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
+            // InternalFSM.g:8668:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); 
-            // InternalFSM.g:8622:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
-            // InternalFSM.g:8622:2: rule__EnumAnnotationAttribute__Alternatives_0
+            // InternalFSM.g:8669:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalFSM.g:8669:2: rule__EnumAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Alternatives_0();
@@ -23502,14 +23658,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__1"
-    // InternalFSM.g:8632:1: rule__EnumAnnotationAttribute__Group__1 : rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ;
+    // InternalFSM.g:8679:1: rule__EnumAnnotationAttribute__Group__1 : rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ;
     public final void rule__EnumAnnotationAttribute__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8636:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 )
-            // InternalFSM.g:8637:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2
+            // InternalFSM.g:8683:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 )
+            // InternalFSM.g:8684:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_5);
             rule__EnumAnnotationAttribute__Group__1__Impl();
@@ -23540,17 +23696,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__1__Impl"
-    // InternalFSM.g:8644:1: rule__EnumAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
+    // InternalFSM.g:8691:1: rule__EnumAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
     public final void rule__EnumAnnotationAttribute__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8648:1: ( ( 'attribute' ) )
-            // InternalFSM.g:8649:1: ( 'attribute' )
+            // InternalFSM.g:8695:1: ( ( 'attribute' ) )
+            // InternalFSM.g:8696:1: ( 'attribute' )
             {
-            // InternalFSM.g:8649:1: ( 'attribute' )
-            // InternalFSM.g:8650:1: 'attribute'
+            // InternalFSM.g:8696:1: ( 'attribute' )
+            // InternalFSM.g:8697:1: 'attribute'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,64,FOLLOW_2); 
@@ -23577,14 +23733,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__2"
-    // InternalFSM.g:8663:1: rule__EnumAnnotationAttribute__Group__2 : rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ;
+    // InternalFSM.g:8710:1: rule__EnumAnnotationAttribute__Group__2 : rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ;
     public final void rule__EnumAnnotationAttribute__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8667:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 )
-            // InternalFSM.g:8668:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3
+            // InternalFSM.g:8714:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 )
+            // InternalFSM.g:8715:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_34);
             rule__EnumAnnotationAttribute__Group__2__Impl();
@@ -23615,21 +23771,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__2__Impl"
-    // InternalFSM.g:8675:1: rule__EnumAnnotationAttribute__Group__2__Impl : ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ;
+    // InternalFSM.g:8722:1: rule__EnumAnnotationAttribute__Group__2__Impl : ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8679:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) )
-            // InternalFSM.g:8680:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
+            // InternalFSM.g:8726:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalFSM.g:8727:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalFSM.g:8680:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
-            // InternalFSM.g:8681:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalFSM.g:8727:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
+            // InternalFSM.g:8728:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); 
-            // InternalFSM.g:8682:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
-            // InternalFSM.g:8682:2: rule__EnumAnnotationAttribute__NameAssignment_2
+            // InternalFSM.g:8729:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalFSM.g:8729:2: rule__EnumAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__NameAssignment_2();
@@ -23662,14 +23818,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__3"
-    // InternalFSM.g:8692:1: rule__EnumAnnotationAttribute__Group__3 : rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ;
+    // InternalFSM.g:8739:1: rule__EnumAnnotationAttribute__Group__3 : rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ;
     public final void rule__EnumAnnotationAttribute__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8696:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 )
-            // InternalFSM.g:8697:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4
+            // InternalFSM.g:8743:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 )
+            // InternalFSM.g:8744:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_7);
             rule__EnumAnnotationAttribute__Group__3__Impl();
@@ -23700,17 +23856,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__3__Impl"
-    // InternalFSM.g:8704:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalFSM.g:8751:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ;
     public final void rule__EnumAnnotationAttribute__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8708:1: ( ( ':' ) )
-            // InternalFSM.g:8709:1: ( ':' )
+            // InternalFSM.g:8755:1: ( ( ':' ) )
+            // InternalFSM.g:8756:1: ( ':' )
             {
-            // InternalFSM.g:8709:1: ( ':' )
-            // InternalFSM.g:8710:1: ':'
+            // InternalFSM.g:8756:1: ( ':' )
+            // InternalFSM.g:8757:1: ':'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,43,FOLLOW_2); 
@@ -23737,14 +23893,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__4"
-    // InternalFSM.g:8723:1: rule__EnumAnnotationAttribute__Group__4 : rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ;
+    // InternalFSM.g:8770:1: rule__EnumAnnotationAttribute__Group__4 : rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ;
     public final void rule__EnumAnnotationAttribute__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8727:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 )
-            // InternalFSM.g:8728:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5
+            // InternalFSM.g:8774:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 )
+            // InternalFSM.g:8775:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5
             {
             pushFollow(FOLLOW_44);
             rule__EnumAnnotationAttribute__Group__4__Impl();
@@ -23775,17 +23931,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__4__Impl"
-    // InternalFSM.g:8735:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ;
+    // InternalFSM.g:8782:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ;
     public final void rule__EnumAnnotationAttribute__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8739:1: ( ( '{' ) )
-            // InternalFSM.g:8740:1: ( '{' )
+            // InternalFSM.g:8786:1: ( ( '{' ) )
+            // InternalFSM.g:8787:1: ( '{' )
             {
-            // InternalFSM.g:8740:1: ( '{' )
-            // InternalFSM.g:8741:1: '{'
+            // InternalFSM.g:8787:1: ( '{' )
+            // InternalFSM.g:8788:1: '{'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,29,FOLLOW_2); 
@@ -23812,14 +23968,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__5"
-    // InternalFSM.g:8754:1: rule__EnumAnnotationAttribute__Group__5 : rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ;
+    // InternalFSM.g:8801:1: rule__EnumAnnotationAttribute__Group__5 : rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ;
     public final void rule__EnumAnnotationAttribute__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8758:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 )
-            // InternalFSM.g:8759:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6
+            // InternalFSM.g:8805:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 )
+            // InternalFSM.g:8806:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6
             {
             pushFollow(FOLLOW_45);
             rule__EnumAnnotationAttribute__Group__5__Impl();
@@ -23850,21 +24006,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__5__Impl"
-    // InternalFSM.g:8766:1: rule__EnumAnnotationAttribute__Group__5__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ;
+    // InternalFSM.g:8813:1: rule__EnumAnnotationAttribute__Group__5__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8770:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) )
-            // InternalFSM.g:8771:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
+            // InternalFSM.g:8817:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) )
+            // InternalFSM.g:8818:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
             {
-            // InternalFSM.g:8771:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
-            // InternalFSM.g:8772:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalFSM.g:8818:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
+            // InternalFSM.g:8819:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); 
-            // InternalFSM.g:8773:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
-            // InternalFSM.g:8773:2: rule__EnumAnnotationAttribute__ValuesAssignment_5
+            // InternalFSM.g:8820:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalFSM.g:8820:2: rule__EnumAnnotationAttribute__ValuesAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_5();
@@ -23897,14 +24053,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__6"
-    // InternalFSM.g:8783:1: rule__EnumAnnotationAttribute__Group__6 : rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ;
+    // InternalFSM.g:8830:1: rule__EnumAnnotationAttribute__Group__6 : rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ;
     public final void rule__EnumAnnotationAttribute__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8787:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 )
-            // InternalFSM.g:8788:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7
+            // InternalFSM.g:8834:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 )
+            // InternalFSM.g:8835:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7
             {
             pushFollow(FOLLOW_45);
             rule__EnumAnnotationAttribute__Group__6__Impl();
@@ -23935,33 +24091,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__6__Impl"
-    // InternalFSM.g:8795:1: rule__EnumAnnotationAttribute__Group__6__Impl : ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ;
+    // InternalFSM.g:8842:1: rule__EnumAnnotationAttribute__Group__6__Impl : ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ;
     public final void rule__EnumAnnotationAttribute__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8799:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) )
-            // InternalFSM.g:8800:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
+            // InternalFSM.g:8846:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) )
+            // InternalFSM.g:8847:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
             {
-            // InternalFSM.g:8800:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
-            // InternalFSM.g:8801:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
+            // InternalFSM.g:8847:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
+            // InternalFSM.g:8848:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); 
-            // InternalFSM.g:8802:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
-            loop73:
+            // InternalFSM.g:8849:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
+            loop74:
             do {
-                int alt73=2;
-                int LA73_0 = input.LA(1);
+                int alt74=2;
+                int LA74_0 = input.LA(1);
 
-                if ( (LA73_0==61) ) {
-                    alt73=1;
+                if ( (LA74_0==61) ) {
+                    alt74=1;
                 }
 
 
-                switch (alt73) {
+                switch (alt74) {
             	case 1 :
-            	    // InternalFSM.g:8802:2: rule__EnumAnnotationAttribute__Group_6__0
+            	    // InternalFSM.g:8849:2: rule__EnumAnnotationAttribute__Group_6__0
             	    {
             	    pushFollow(FOLLOW_39);
             	    rule__EnumAnnotationAttribute__Group_6__0();
@@ -23973,7 +24129,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop73;
+            	    break loop74;
                 }
             } while (true);
 
@@ -24000,14 +24156,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__7"
-    // InternalFSM.g:8812:1: rule__EnumAnnotationAttribute__Group__7 : rule__EnumAnnotationAttribute__Group__7__Impl ;
+    // InternalFSM.g:8859:1: rule__EnumAnnotationAttribute__Group__7 : rule__EnumAnnotationAttribute__Group__7__Impl ;
     public final void rule__EnumAnnotationAttribute__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8816:1: ( rule__EnumAnnotationAttribute__Group__7__Impl )
-            // InternalFSM.g:8817:2: rule__EnumAnnotationAttribute__Group__7__Impl
+            // InternalFSM.g:8863:1: ( rule__EnumAnnotationAttribute__Group__7__Impl )
+            // InternalFSM.g:8864:2: rule__EnumAnnotationAttribute__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__7__Impl();
@@ -24033,17 +24189,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__7__Impl"
-    // InternalFSM.g:8823:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ;
+    // InternalFSM.g:8870:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ;
     public final void rule__EnumAnnotationAttribute__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8827:1: ( ( '}' ) )
-            // InternalFSM.g:8828:1: ( '}' )
+            // InternalFSM.g:8874:1: ( ( '}' ) )
+            // InternalFSM.g:8875:1: ( '}' )
             {
-            // InternalFSM.g:8828:1: ( '}' )
-            // InternalFSM.g:8829:1: '}'
+            // InternalFSM.g:8875:1: ( '}' )
+            // InternalFSM.g:8876:1: '}'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); 
             match(input,30,FOLLOW_2); 
@@ -24070,14 +24226,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0"
-    // InternalFSM.g:8858:1: rule__EnumAnnotationAttribute__Group_6__0 : rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ;
+    // InternalFSM.g:8905:1: rule__EnumAnnotationAttribute__Group_6__0 : rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ;
     public final void rule__EnumAnnotationAttribute__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8862:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 )
-            // InternalFSM.g:8863:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1
+            // InternalFSM.g:8909:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 )
+            // InternalFSM.g:8910:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1
             {
             pushFollow(FOLLOW_44);
             rule__EnumAnnotationAttribute__Group_6__0__Impl();
@@ -24108,17 +24264,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0__Impl"
-    // InternalFSM.g:8870:1: rule__EnumAnnotationAttribute__Group_6__0__Impl : ( ',' ) ;
+    // InternalFSM.g:8917:1: rule__EnumAnnotationAttribute__Group_6__0__Impl : ( ',' ) ;
     public final void rule__EnumAnnotationAttribute__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8874:1: ( ( ',' ) )
-            // InternalFSM.g:8875:1: ( ',' )
+            // InternalFSM.g:8921:1: ( ( ',' ) )
+            // InternalFSM.g:8922:1: ( ',' )
             {
-            // InternalFSM.g:8875:1: ( ',' )
-            // InternalFSM.g:8876:1: ','
+            // InternalFSM.g:8922:1: ( ',' )
+            // InternalFSM.g:8923:1: ','
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); 
             match(input,61,FOLLOW_2); 
@@ -24145,14 +24301,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1"
-    // InternalFSM.g:8889:1: rule__EnumAnnotationAttribute__Group_6__1 : rule__EnumAnnotationAttribute__Group_6__1__Impl ;
+    // InternalFSM.g:8936:1: rule__EnumAnnotationAttribute__Group_6__1 : rule__EnumAnnotationAttribute__Group_6__1__Impl ;
     public final void rule__EnumAnnotationAttribute__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8893:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl )
-            // InternalFSM.g:8894:2: rule__EnumAnnotationAttribute__Group_6__1__Impl
+            // InternalFSM.g:8940:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl )
+            // InternalFSM.g:8941:2: rule__EnumAnnotationAttribute__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group_6__1__Impl();
@@ -24178,21 +24334,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1__Impl"
-    // InternalFSM.g:8900:1: rule__EnumAnnotationAttribute__Group_6__1__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ;
+    // InternalFSM.g:8947:1: rule__EnumAnnotationAttribute__Group_6__1__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8904:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) )
-            // InternalFSM.g:8905:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
+            // InternalFSM.g:8951:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) )
+            // InternalFSM.g:8952:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
             {
-            // InternalFSM.g:8905:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
-            // InternalFSM.g:8906:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
+            // InternalFSM.g:8952:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
+            // InternalFSM.g:8953:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); 
-            // InternalFSM.g:8907:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
-            // InternalFSM.g:8907:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1
+            // InternalFSM.g:8954:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
+            // InternalFSM.g:8954:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_6_1();
@@ -24225,14 +24381,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__0"
-    // InternalFSM.g:8923:1: rule__ImportedFQN__Group__0 : rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ;
+    // InternalFSM.g:8970:1: rule__ImportedFQN__Group__0 : rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ;
     public final void rule__ImportedFQN__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8927:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 )
-            // InternalFSM.g:8928:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1
+            // InternalFSM.g:8974:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 )
+            // InternalFSM.g:8975:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1
             {
             pushFollow(FOLLOW_46);
             rule__ImportedFQN__Group__0__Impl();
@@ -24263,17 +24419,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__0__Impl"
-    // InternalFSM.g:8935:1: rule__ImportedFQN__Group__0__Impl : ( ruleFQN ) ;
+    // InternalFSM.g:8982:1: rule__ImportedFQN__Group__0__Impl : ( ruleFQN ) ;
     public final void rule__ImportedFQN__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8939:1: ( ( ruleFQN ) )
-            // InternalFSM.g:8940:1: ( ruleFQN )
+            // InternalFSM.g:8986:1: ( ( ruleFQN ) )
+            // InternalFSM.g:8987:1: ( ruleFQN )
             {
-            // InternalFSM.g:8940:1: ( ruleFQN )
-            // InternalFSM.g:8941:1: ruleFQN
+            // InternalFSM.g:8987:1: ( ruleFQN )
+            // InternalFSM.g:8988:1: ruleFQN
             {
              before(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
             pushFollow(FOLLOW_2);
@@ -24304,14 +24460,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__1"
-    // InternalFSM.g:8952:1: rule__ImportedFQN__Group__1 : rule__ImportedFQN__Group__1__Impl ;
+    // InternalFSM.g:8999:1: rule__ImportedFQN__Group__1 : rule__ImportedFQN__Group__1__Impl ;
     public final void rule__ImportedFQN__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8956:1: ( rule__ImportedFQN__Group__1__Impl )
-            // InternalFSM.g:8957:2: rule__ImportedFQN__Group__1__Impl
+            // InternalFSM.g:9003:1: ( rule__ImportedFQN__Group__1__Impl )
+            // InternalFSM.g:9004:2: rule__ImportedFQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__1__Impl();
@@ -24337,29 +24493,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__1__Impl"
-    // InternalFSM.g:8963:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ;
+    // InternalFSM.g:9010:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ;
     public final void rule__ImportedFQN__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8967:1: ( ( ( '.*' )? ) )
-            // InternalFSM.g:8968:1: ( ( '.*' )? )
+            // InternalFSM.g:9014:1: ( ( ( '.*' )? ) )
+            // InternalFSM.g:9015:1: ( ( '.*' )? )
             {
-            // InternalFSM.g:8968:1: ( ( '.*' )? )
-            // InternalFSM.g:8969:1: ( '.*' )?
+            // InternalFSM.g:9015:1: ( ( '.*' )? )
+            // InternalFSM.g:9016:1: ( '.*' )?
             {
              before(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); 
-            // InternalFSM.g:8970:1: ( '.*' )?
-            int alt74=2;
-            int LA74_0 = input.LA(1);
+            // InternalFSM.g:9017:1: ( '.*' )?
+            int alt75=2;
+            int LA75_0 = input.LA(1);
 
-            if ( (LA74_0==65) ) {
-                alt74=1;
+            if ( (LA75_0==65) ) {
+                alt75=1;
             }
-            switch (alt74) {
+            switch (alt75) {
                 case 1 :
-                    // InternalFSM.g:8971:2: '.*'
+                    // InternalFSM.g:9018:2: '.*'
                     {
                     match(input,65,FOLLOW_2); 
 
@@ -24391,14 +24547,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__0"
-    // InternalFSM.g:8986:1: rule__Documentation__Group__0 : rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ;
+    // InternalFSM.g:9033:1: rule__Documentation__Group__0 : rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ;
     public final void rule__Documentation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:8990:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 )
-            // InternalFSM.g:8991:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1
+            // InternalFSM.g:9037:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 )
+            // InternalFSM.g:9038:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1
             {
             pushFollow(FOLLOW_17);
             rule__Documentation__Group__0__Impl();
@@ -24429,21 +24585,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__0__Impl"
-    // InternalFSM.g:8998:1: rule__Documentation__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:9045:1: rule__Documentation__Group__0__Impl : ( () ) ;
     public final void rule__Documentation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9002:1: ( ( () ) )
-            // InternalFSM.g:9003:1: ( () )
+            // InternalFSM.g:9049:1: ( ( () ) )
+            // InternalFSM.g:9050:1: ( () )
             {
-            // InternalFSM.g:9003:1: ( () )
-            // InternalFSM.g:9004:1: ()
+            // InternalFSM.g:9050:1: ( () )
+            // InternalFSM.g:9051:1: ()
             {
              before(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); 
-            // InternalFSM.g:9005:1: ()
-            // InternalFSM.g:9007:1: 
+            // InternalFSM.g:9052:1: ()
+            // InternalFSM.g:9054:1: 
             {
             }
 
@@ -24466,14 +24622,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__1"
-    // InternalFSM.g:9017:1: rule__Documentation__Group__1 : rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ;
+    // InternalFSM.g:9064:1: rule__Documentation__Group__1 : rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ;
     public final void rule__Documentation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9021:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 )
-            // InternalFSM.g:9022:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2
+            // InternalFSM.g:9068:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 )
+            // InternalFSM.g:9069:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2
             {
             pushFollow(FOLLOW_47);
             rule__Documentation__Group__1__Impl();
@@ -24504,17 +24660,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__1__Impl"
-    // InternalFSM.g:9029:1: rule__Documentation__Group__1__Impl : ( '[' ) ;
+    // InternalFSM.g:9076:1: rule__Documentation__Group__1__Impl : ( '[' ) ;
     public final void rule__Documentation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9033:1: ( ( '[' ) )
-            // InternalFSM.g:9034:1: ( '[' )
+            // InternalFSM.g:9080:1: ( ( '[' ) )
+            // InternalFSM.g:9081:1: ( '[' )
             {
-            // InternalFSM.g:9034:1: ( '[' )
-            // InternalFSM.g:9035:1: '['
+            // InternalFSM.g:9081:1: ( '[' )
+            // InternalFSM.g:9082:1: '['
             {
              before(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); 
             match(input,66,FOLLOW_2); 
@@ -24541,14 +24697,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__2"
-    // InternalFSM.g:9048:1: rule__Documentation__Group__2 : rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ;
+    // InternalFSM.g:9095:1: rule__Documentation__Group__2 : rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ;
     public final void rule__Documentation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9052:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 )
-            // InternalFSM.g:9053:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3
+            // InternalFSM.g:9099:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 )
+            // InternalFSM.g:9100:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3
             {
             pushFollow(FOLLOW_47);
             rule__Documentation__Group__2__Impl();
@@ -24579,33 +24735,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__2__Impl"
-    // InternalFSM.g:9060:1: rule__Documentation__Group__2__Impl : ( ( rule__Documentation__LinesAssignment_2 )* ) ;
+    // InternalFSM.g:9107:1: rule__Documentation__Group__2__Impl : ( ( rule__Documentation__LinesAssignment_2 )* ) ;
     public final void rule__Documentation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9064:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) )
-            // InternalFSM.g:9065:1: ( ( rule__Documentation__LinesAssignment_2 )* )
+            // InternalFSM.g:9111:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) )
+            // InternalFSM.g:9112:1: ( ( rule__Documentation__LinesAssignment_2 )* )
             {
-            // InternalFSM.g:9065:1: ( ( rule__Documentation__LinesAssignment_2 )* )
-            // InternalFSM.g:9066:1: ( rule__Documentation__LinesAssignment_2 )*
+            // InternalFSM.g:9112:1: ( ( rule__Documentation__LinesAssignment_2 )* )
+            // InternalFSM.g:9113:1: ( rule__Documentation__LinesAssignment_2 )*
             {
              before(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); 
-            // InternalFSM.g:9067:1: ( rule__Documentation__LinesAssignment_2 )*
-            loop75:
+            // InternalFSM.g:9114:1: ( rule__Documentation__LinesAssignment_2 )*
+            loop76:
             do {
-                int alt75=2;
-                int LA75_0 = input.LA(1);
+                int alt76=2;
+                int LA76_0 = input.LA(1);
 
-                if ( (LA75_0==RULE_STRING) ) {
-                    alt75=1;
+                if ( (LA76_0==RULE_STRING) ) {
+                    alt76=1;
                 }
 
 
-                switch (alt75) {
+                switch (alt76) {
             	case 1 :
-            	    // InternalFSM.g:9067:2: rule__Documentation__LinesAssignment_2
+            	    // InternalFSM.g:9114:2: rule__Documentation__LinesAssignment_2
             	    {
             	    pushFollow(FOLLOW_15);
             	    rule__Documentation__LinesAssignment_2();
@@ -24617,7 +24773,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop75;
+            	    break loop76;
                 }
             } while (true);
 
@@ -24644,14 +24800,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__3"
-    // InternalFSM.g:9077:1: rule__Documentation__Group__3 : rule__Documentation__Group__3__Impl ;
+    // InternalFSM.g:9124:1: rule__Documentation__Group__3 : rule__Documentation__Group__3__Impl ;
     public final void rule__Documentation__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9081:1: ( rule__Documentation__Group__3__Impl )
-            // InternalFSM.g:9082:2: rule__Documentation__Group__3__Impl
+            // InternalFSM.g:9128:1: ( rule__Documentation__Group__3__Impl )
+            // InternalFSM.g:9129:2: rule__Documentation__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__3__Impl();
@@ -24677,17 +24833,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__3__Impl"
-    // InternalFSM.g:9088:1: rule__Documentation__Group__3__Impl : ( ']' ) ;
+    // InternalFSM.g:9135:1: rule__Documentation__Group__3__Impl : ( ']' ) ;
     public final void rule__Documentation__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9092:1: ( ( ']' ) )
-            // InternalFSM.g:9093:1: ( ']' )
+            // InternalFSM.g:9139:1: ( ( ']' ) )
+            // InternalFSM.g:9140:1: ( ']' )
             {
-            // InternalFSM.g:9093:1: ( ']' )
-            // InternalFSM.g:9094:1: ']'
+            // InternalFSM.g:9140:1: ( ']' )
+            // InternalFSM.g:9141:1: ']'
             {
              before(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); 
             match(input,67,FOLLOW_2); 
@@ -24714,14 +24870,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__0"
-    // InternalFSM.g:9121:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ;
+    // InternalFSM.g:9168:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ;
     public final void rule__BooleanLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9125:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 )
-            // InternalFSM.g:9126:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1
+            // InternalFSM.g:9172:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 )
+            // InternalFSM.g:9173:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1
             {
             pushFollow(FOLLOW_48);
             rule__BooleanLiteral__Group__0__Impl();
@@ -24752,21 +24908,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__0__Impl"
-    // InternalFSM.g:9133:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:9180:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ;
     public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9137:1: ( ( () ) )
-            // InternalFSM.g:9138:1: ( () )
+            // InternalFSM.g:9184:1: ( ( () ) )
+            // InternalFSM.g:9185:1: ( () )
             {
-            // InternalFSM.g:9138:1: ( () )
-            // InternalFSM.g:9139:1: ()
+            // InternalFSM.g:9185:1: ( () )
+            // InternalFSM.g:9186:1: ()
             {
              before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); 
-            // InternalFSM.g:9140:1: ()
-            // InternalFSM.g:9142:1: 
+            // InternalFSM.g:9187:1: ()
+            // InternalFSM.g:9189:1: 
             {
             }
 
@@ -24789,14 +24945,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__1"
-    // InternalFSM.g:9152:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ;
+    // InternalFSM.g:9199:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ;
     public final void rule__BooleanLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9156:1: ( rule__BooleanLiteral__Group__1__Impl )
-            // InternalFSM.g:9157:2: rule__BooleanLiteral__Group__1__Impl
+            // InternalFSM.g:9203:1: ( rule__BooleanLiteral__Group__1__Impl )
+            // InternalFSM.g:9204:2: rule__BooleanLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__1__Impl();
@@ -24822,21 +24978,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__1__Impl"
-    // InternalFSM.g:9163:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ;
+    // InternalFSM.g:9210:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ;
     public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9167:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) )
-            // InternalFSM.g:9168:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
+            // InternalFSM.g:9214:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) )
+            // InternalFSM.g:9215:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
             {
-            // InternalFSM.g:9168:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
-            // InternalFSM.g:9169:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalFSM.g:9215:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
+            // InternalFSM.g:9216:1: ( rule__BooleanLiteral__Alternatives_1 )
             {
              before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); 
-            // InternalFSM.g:9170:1: ( rule__BooleanLiteral__Alternatives_1 )
-            // InternalFSM.g:9170:2: rule__BooleanLiteral__Alternatives_1
+            // InternalFSM.g:9217:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalFSM.g:9217:2: rule__BooleanLiteral__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Alternatives_1();
@@ -24869,14 +25025,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__0"
-    // InternalFSM.g:9184:1: rule__RealLiteral__Group__0 : rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ;
+    // InternalFSM.g:9231:1: rule__RealLiteral__Group__0 : rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ;
     public final void rule__RealLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9188:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 )
-            // InternalFSM.g:9189:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1
+            // InternalFSM.g:9235:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 )
+            // InternalFSM.g:9236:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1
             {
             pushFollow(FOLLOW_49);
             rule__RealLiteral__Group__0__Impl();
@@ -24907,21 +25063,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__0__Impl"
-    // InternalFSM.g:9196:1: rule__RealLiteral__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:9243:1: rule__RealLiteral__Group__0__Impl : ( () ) ;
     public final void rule__RealLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9200:1: ( ( () ) )
-            // InternalFSM.g:9201:1: ( () )
+            // InternalFSM.g:9247:1: ( ( () ) )
+            // InternalFSM.g:9248:1: ( () )
             {
-            // InternalFSM.g:9201:1: ( () )
-            // InternalFSM.g:9202:1: ()
+            // InternalFSM.g:9248:1: ( () )
+            // InternalFSM.g:9249:1: ()
             {
              before(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); 
-            // InternalFSM.g:9203:1: ()
-            // InternalFSM.g:9205:1: 
+            // InternalFSM.g:9250:1: ()
+            // InternalFSM.g:9252:1: 
             {
             }
 
@@ -24944,14 +25100,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__1"
-    // InternalFSM.g:9215:1: rule__RealLiteral__Group__1 : rule__RealLiteral__Group__1__Impl ;
+    // InternalFSM.g:9262:1: rule__RealLiteral__Group__1 : rule__RealLiteral__Group__1__Impl ;
     public final void rule__RealLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9219:1: ( rule__RealLiteral__Group__1__Impl )
-            // InternalFSM.g:9220:2: rule__RealLiteral__Group__1__Impl
+            // InternalFSM.g:9266:1: ( rule__RealLiteral__Group__1__Impl )
+            // InternalFSM.g:9267:2: rule__RealLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__1__Impl();
@@ -24977,21 +25133,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__1__Impl"
-    // InternalFSM.g:9226:1: rule__RealLiteral__Group__1__Impl : ( ( rule__RealLiteral__ValueAssignment_1 ) ) ;
+    // InternalFSM.g:9273:1: rule__RealLiteral__Group__1__Impl : ( ( rule__RealLiteral__ValueAssignment_1 ) ) ;
     public final void rule__RealLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9230:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) )
-            // InternalFSM.g:9231:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9277:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) )
+            // InternalFSM.g:9278:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
             {
-            // InternalFSM.g:9231:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
-            // InternalFSM.g:9232:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9278:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9279:1: ( rule__RealLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); 
-            // InternalFSM.g:9233:1: ( rule__RealLiteral__ValueAssignment_1 )
-            // InternalFSM.g:9233:2: rule__RealLiteral__ValueAssignment_1
+            // InternalFSM.g:9280:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9280:2: rule__RealLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__ValueAssignment_1();
@@ -25024,14 +25180,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__0"
-    // InternalFSM.g:9247:1: rule__IntLiteral__Group__0 : rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ;
+    // InternalFSM.g:9294:1: rule__IntLiteral__Group__0 : rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ;
     public final void rule__IntLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9251:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 )
-            // InternalFSM.g:9252:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1
+            // InternalFSM.g:9298:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 )
+            // InternalFSM.g:9299:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1
             {
             pushFollow(FOLLOW_49);
             rule__IntLiteral__Group__0__Impl();
@@ -25062,21 +25218,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__0__Impl"
-    // InternalFSM.g:9259:1: rule__IntLiteral__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:9306:1: rule__IntLiteral__Group__0__Impl : ( () ) ;
     public final void rule__IntLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9263:1: ( ( () ) )
-            // InternalFSM.g:9264:1: ( () )
+            // InternalFSM.g:9310:1: ( ( () ) )
+            // InternalFSM.g:9311:1: ( () )
             {
-            // InternalFSM.g:9264:1: ( () )
-            // InternalFSM.g:9265:1: ()
+            // InternalFSM.g:9311:1: ( () )
+            // InternalFSM.g:9312:1: ()
             {
              before(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); 
-            // InternalFSM.g:9266:1: ()
-            // InternalFSM.g:9268:1: 
+            // InternalFSM.g:9313:1: ()
+            // InternalFSM.g:9315:1: 
             {
             }
 
@@ -25099,14 +25255,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__1"
-    // InternalFSM.g:9278:1: rule__IntLiteral__Group__1 : rule__IntLiteral__Group__1__Impl ;
+    // InternalFSM.g:9325:1: rule__IntLiteral__Group__1 : rule__IntLiteral__Group__1__Impl ;
     public final void rule__IntLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9282:1: ( rule__IntLiteral__Group__1__Impl )
-            // InternalFSM.g:9283:2: rule__IntLiteral__Group__1__Impl
+            // InternalFSM.g:9329:1: ( rule__IntLiteral__Group__1__Impl )
+            // InternalFSM.g:9330:2: rule__IntLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__1__Impl();
@@ -25132,21 +25288,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__1__Impl"
-    // InternalFSM.g:9289:1: rule__IntLiteral__Group__1__Impl : ( ( rule__IntLiteral__ValueAssignment_1 ) ) ;
+    // InternalFSM.g:9336:1: rule__IntLiteral__Group__1__Impl : ( ( rule__IntLiteral__ValueAssignment_1 ) ) ;
     public final void rule__IntLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9293:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) )
-            // InternalFSM.g:9294:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9340:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) )
+            // InternalFSM.g:9341:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
             {
-            // InternalFSM.g:9294:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
-            // InternalFSM.g:9295:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9341:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9342:1: ( rule__IntLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); 
-            // InternalFSM.g:9296:1: ( rule__IntLiteral__ValueAssignment_1 )
-            // InternalFSM.g:9296:2: rule__IntLiteral__ValueAssignment_1
+            // InternalFSM.g:9343:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9343:2: rule__IntLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__ValueAssignment_1();
@@ -25179,14 +25335,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__0"
-    // InternalFSM.g:9310:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ;
+    // InternalFSM.g:9357:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ;
     public final void rule__StringLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9314:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
-            // InternalFSM.g:9315:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
+            // InternalFSM.g:9361:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
+            // InternalFSM.g:9362:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
             {
             pushFollow(FOLLOW_41);
             rule__StringLiteral__Group__0__Impl();
@@ -25217,21 +25373,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__0__Impl"
-    // InternalFSM.g:9322:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
+    // InternalFSM.g:9369:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
     public final void rule__StringLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9326:1: ( ( () ) )
-            // InternalFSM.g:9327:1: ( () )
+            // InternalFSM.g:9373:1: ( ( () ) )
+            // InternalFSM.g:9374:1: ( () )
             {
-            // InternalFSM.g:9327:1: ( () )
-            // InternalFSM.g:9328:1: ()
+            // InternalFSM.g:9374:1: ( () )
+            // InternalFSM.g:9375:1: ()
             {
              before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); 
-            // InternalFSM.g:9329:1: ()
-            // InternalFSM.g:9331:1: 
+            // InternalFSM.g:9376:1: ()
+            // InternalFSM.g:9378:1: 
             {
             }
 
@@ -25254,14 +25410,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__1"
-    // InternalFSM.g:9341:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ;
+    // InternalFSM.g:9388:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ;
     public final void rule__StringLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9345:1: ( rule__StringLiteral__Group__1__Impl )
-            // InternalFSM.g:9346:2: rule__StringLiteral__Group__1__Impl
+            // InternalFSM.g:9392:1: ( rule__StringLiteral__Group__1__Impl )
+            // InternalFSM.g:9393:2: rule__StringLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__1__Impl();
@@ -25287,21 +25443,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__1__Impl"
-    // InternalFSM.g:9352:1: rule__StringLiteral__Group__1__Impl : ( ( rule__StringLiteral__ValueAssignment_1 ) ) ;
+    // InternalFSM.g:9399:1: rule__StringLiteral__Group__1__Impl : ( ( rule__StringLiteral__ValueAssignment_1 ) ) ;
     public final void rule__StringLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9356:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) )
-            // InternalFSM.g:9357:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9403:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) )
+            // InternalFSM.g:9404:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
             {
-            // InternalFSM.g:9357:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
-            // InternalFSM.g:9358:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9404:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
+            // InternalFSM.g:9405:1: ( rule__StringLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); 
-            // InternalFSM.g:9359:1: ( rule__StringLiteral__ValueAssignment_1 )
-            // InternalFSM.g:9359:2: rule__StringLiteral__ValueAssignment_1
+            // InternalFSM.g:9406:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalFSM.g:9406:2: rule__StringLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__ValueAssignment_1();
@@ -25334,14 +25490,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__0"
-    // InternalFSM.g:9373:1: rule__Integer__Group_0__0 : rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ;
+    // InternalFSM.g:9420:1: rule__Integer__Group_0__0 : rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ;
     public final void rule__Integer__Group_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9377:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 )
-            // InternalFSM.g:9378:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1
+            // InternalFSM.g:9424:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 )
+            // InternalFSM.g:9425:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1
             {
             pushFollow(FOLLOW_50);
             rule__Integer__Group_0__0__Impl();
@@ -25372,29 +25528,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__0__Impl"
-    // InternalFSM.g:9385:1: rule__Integer__Group_0__0__Impl : ( ( rule__Integer__Alternatives_0_0 )? ) ;
+    // InternalFSM.g:9432:1: rule__Integer__Group_0__0__Impl : ( ( rule__Integer__Alternatives_0_0 )? ) ;
     public final void rule__Integer__Group_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9389:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) )
-            // InternalFSM.g:9390:1: ( ( rule__Integer__Alternatives_0_0 )? )
+            // InternalFSM.g:9436:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) )
+            // InternalFSM.g:9437:1: ( ( rule__Integer__Alternatives_0_0 )? )
             {
-            // InternalFSM.g:9390:1: ( ( rule__Integer__Alternatives_0_0 )? )
-            // InternalFSM.g:9391:1: ( rule__Integer__Alternatives_0_0 )?
+            // InternalFSM.g:9437:1: ( ( rule__Integer__Alternatives_0_0 )? )
+            // InternalFSM.g:9438:1: ( rule__Integer__Alternatives_0_0 )?
             {
              before(grammarAccess.getIntegerAccess().getAlternatives_0_0()); 
-            // InternalFSM.g:9392:1: ( rule__Integer__Alternatives_0_0 )?
-            int alt76=2;
-            int LA76_0 = input.LA(1);
+            // InternalFSM.g:9439:1: ( rule__Integer__Alternatives_0_0 )?
+            int alt77=2;
+            int LA77_0 = input.LA(1);
 
-            if ( ((LA76_0>=15 && LA76_0<=16)) ) {
-                alt76=1;
+            if ( ((LA77_0>=15 && LA77_0<=16)) ) {
+                alt77=1;
             }
-            switch (alt76) {
+            switch (alt77) {
                 case 1 :
-                    // InternalFSM.g:9392:2: rule__Integer__Alternatives_0_0
+                    // InternalFSM.g:9439:2: rule__Integer__Alternatives_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Alternatives_0_0();
@@ -25430,14 +25586,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__1"
-    // InternalFSM.g:9402:1: rule__Integer__Group_0__1 : rule__Integer__Group_0__1__Impl ;
+    // InternalFSM.g:9449:1: rule__Integer__Group_0__1 : rule__Integer__Group_0__1__Impl ;
     public final void rule__Integer__Group_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9406:1: ( rule__Integer__Group_0__1__Impl )
-            // InternalFSM.g:9407:2: rule__Integer__Group_0__1__Impl
+            // InternalFSM.g:9453:1: ( rule__Integer__Group_0__1__Impl )
+            // InternalFSM.g:9454:2: rule__Integer__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Group_0__1__Impl();
@@ -25463,17 +25619,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__1__Impl"
-    // InternalFSM.g:9413:1: rule__Integer__Group_0__1__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9460:1: rule__Integer__Group_0__1__Impl : ( RULE_INT ) ;
     public final void rule__Integer__Group_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9417:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9418:1: ( RULE_INT )
+            // InternalFSM.g:9464:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9465:1: ( RULE_INT )
             {
-            // InternalFSM.g:9418:1: ( RULE_INT )
-            // InternalFSM.g:9419:1: RULE_INT
+            // InternalFSM.g:9465:1: ( RULE_INT )
+            // InternalFSM.g:9466:1: RULE_INT
             {
              before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_0_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -25500,14 +25656,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__0"
-    // InternalFSM.g:9434:1: rule__Decimal__Group__0 : rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ;
+    // InternalFSM.g:9481:1: rule__Decimal__Group__0 : rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ;
     public final void rule__Decimal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9438:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 )
-            // InternalFSM.g:9439:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1
+            // InternalFSM.g:9485:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 )
+            // InternalFSM.g:9486:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1
             {
             pushFollow(FOLLOW_50);
             rule__Decimal__Group__0__Impl();
@@ -25538,29 +25694,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__0__Impl"
-    // InternalFSM.g:9446:1: rule__Decimal__Group__0__Impl : ( ( rule__Decimal__Alternatives_0 )? ) ;
+    // InternalFSM.g:9493:1: rule__Decimal__Group__0__Impl : ( ( rule__Decimal__Alternatives_0 )? ) ;
     public final void rule__Decimal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9450:1: ( ( ( rule__Decimal__Alternatives_0 )? ) )
-            // InternalFSM.g:9451:1: ( ( rule__Decimal__Alternatives_0 )? )
+            // InternalFSM.g:9497:1: ( ( ( rule__Decimal__Alternatives_0 )? ) )
+            // InternalFSM.g:9498:1: ( ( rule__Decimal__Alternatives_0 )? )
             {
-            // InternalFSM.g:9451:1: ( ( rule__Decimal__Alternatives_0 )? )
-            // InternalFSM.g:9452:1: ( rule__Decimal__Alternatives_0 )?
+            // InternalFSM.g:9498:1: ( ( rule__Decimal__Alternatives_0 )? )
+            // InternalFSM.g:9499:1: ( rule__Decimal__Alternatives_0 )?
             {
              before(grammarAccess.getDecimalAccess().getAlternatives_0()); 
-            // InternalFSM.g:9453:1: ( rule__Decimal__Alternatives_0 )?
-            int alt77=2;
-            int LA77_0 = input.LA(1);
+            // InternalFSM.g:9500:1: ( rule__Decimal__Alternatives_0 )?
+            int alt78=2;
+            int LA78_0 = input.LA(1);
 
-            if ( ((LA77_0>=15 && LA77_0<=16)) ) {
-                alt77=1;
+            if ( ((LA78_0>=15 && LA78_0<=16)) ) {
+                alt78=1;
             }
-            switch (alt77) {
+            switch (alt78) {
                 case 1 :
-                    // InternalFSM.g:9453:2: rule__Decimal__Alternatives_0
+                    // InternalFSM.g:9500:2: rule__Decimal__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Decimal__Alternatives_0();
@@ -25596,14 +25752,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__1"
-    // InternalFSM.g:9463:1: rule__Decimal__Group__1 : rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ;
+    // InternalFSM.g:9510:1: rule__Decimal__Group__1 : rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ;
     public final void rule__Decimal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9467:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 )
-            // InternalFSM.g:9468:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2
+            // InternalFSM.g:9514:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 )
+            // InternalFSM.g:9515:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2
             {
             pushFollow(FOLLOW_51);
             rule__Decimal__Group__1__Impl();
@@ -25634,17 +25790,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__1__Impl"
-    // InternalFSM.g:9475:1: rule__Decimal__Group__1__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9522:1: rule__Decimal__Group__1__Impl : ( RULE_INT ) ;
     public final void rule__Decimal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9479:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9480:1: ( RULE_INT )
+            // InternalFSM.g:9526:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9527:1: ( RULE_INT )
             {
-            // InternalFSM.g:9480:1: ( RULE_INT )
-            // InternalFSM.g:9481:1: RULE_INT
+            // InternalFSM.g:9527:1: ( RULE_INT )
+            // InternalFSM.g:9528:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -25671,14 +25827,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__2"
-    // InternalFSM.g:9492:1: rule__Decimal__Group__2 : rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ;
+    // InternalFSM.g:9539:1: rule__Decimal__Group__2 : rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ;
     public final void rule__Decimal__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9496:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 )
-            // InternalFSM.g:9497:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3
+            // InternalFSM.g:9543:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 )
+            // InternalFSM.g:9544:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3
             {
             pushFollow(FOLLOW_52);
             rule__Decimal__Group__2__Impl();
@@ -25709,17 +25865,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__2__Impl"
-    // InternalFSM.g:9504:1: rule__Decimal__Group__2__Impl : ( '.' ) ;
+    // InternalFSM.g:9551:1: rule__Decimal__Group__2__Impl : ( '.' ) ;
     public final void rule__Decimal__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9508:1: ( ( '.' ) )
-            // InternalFSM.g:9509:1: ( '.' )
+            // InternalFSM.g:9555:1: ( ( '.' ) )
+            // InternalFSM.g:9556:1: ( '.' )
             {
-            // InternalFSM.g:9509:1: ( '.' )
-            // InternalFSM.g:9510:1: '.'
+            // InternalFSM.g:9556:1: ( '.' )
+            // InternalFSM.g:9557:1: '.'
             {
              before(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); 
             match(input,68,FOLLOW_2); 
@@ -25746,14 +25902,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__3"
-    // InternalFSM.g:9523:1: rule__Decimal__Group__3 : rule__Decimal__Group__3__Impl ;
+    // InternalFSM.g:9570:1: rule__Decimal__Group__3 : rule__Decimal__Group__3__Impl ;
     public final void rule__Decimal__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9527:1: ( rule__Decimal__Group__3__Impl )
-            // InternalFSM.g:9528:2: rule__Decimal__Group__3__Impl
+            // InternalFSM.g:9574:1: ( rule__Decimal__Group__3__Impl )
+            // InternalFSM.g:9575:2: rule__Decimal__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__3__Impl();
@@ -25779,17 +25935,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__3__Impl"
-    // InternalFSM.g:9534:1: rule__Decimal__Group__3__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9581:1: rule__Decimal__Group__3__Impl : ( RULE_INT ) ;
     public final void rule__Decimal__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9538:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9539:1: ( RULE_INT )
+            // InternalFSM.g:9585:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9586:1: ( RULE_INT )
             {
-            // InternalFSM.g:9539:1: ( RULE_INT )
-            // InternalFSM.g:9540:1: RULE_INT
+            // InternalFSM.g:9586:1: ( RULE_INT )
+            // InternalFSM.g:9587:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -25816,14 +25972,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__0"
-    // InternalFSM.g:9559:1: rule__DecimalExp__Group__0 : rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ;
+    // InternalFSM.g:9606:1: rule__DecimalExp__Group__0 : rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ;
     public final void rule__DecimalExp__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9563:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 )
-            // InternalFSM.g:9564:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1
+            // InternalFSM.g:9610:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 )
+            // InternalFSM.g:9611:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1
             {
             pushFollow(FOLLOW_49);
             rule__DecimalExp__Group__0__Impl();
@@ -25854,29 +26010,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__0__Impl"
-    // InternalFSM.g:9571:1: rule__DecimalExp__Group__0__Impl : ( ( rule__DecimalExp__Alternatives_0 )? ) ;
+    // InternalFSM.g:9618:1: rule__DecimalExp__Group__0__Impl : ( ( rule__DecimalExp__Alternatives_0 )? ) ;
     public final void rule__DecimalExp__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9575:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) )
-            // InternalFSM.g:9576:1: ( ( rule__DecimalExp__Alternatives_0 )? )
+            // InternalFSM.g:9622:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) )
+            // InternalFSM.g:9623:1: ( ( rule__DecimalExp__Alternatives_0 )? )
             {
-            // InternalFSM.g:9576:1: ( ( rule__DecimalExp__Alternatives_0 )? )
-            // InternalFSM.g:9577:1: ( rule__DecimalExp__Alternatives_0 )?
+            // InternalFSM.g:9623:1: ( ( rule__DecimalExp__Alternatives_0 )? )
+            // InternalFSM.g:9624:1: ( rule__DecimalExp__Alternatives_0 )?
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_0()); 
-            // InternalFSM.g:9578:1: ( rule__DecimalExp__Alternatives_0 )?
-            int alt78=2;
-            int LA78_0 = input.LA(1);
+            // InternalFSM.g:9625:1: ( rule__DecimalExp__Alternatives_0 )?
+            int alt79=2;
+            int LA79_0 = input.LA(1);
 
-            if ( ((LA78_0>=15 && LA78_0<=16)) ) {
-                alt78=1;
+            if ( ((LA79_0>=15 && LA79_0<=16)) ) {
+                alt79=1;
             }
-            switch (alt78) {
+            switch (alt79) {
                 case 1 :
-                    // InternalFSM.g:9578:2: rule__DecimalExp__Alternatives_0
+                    // InternalFSM.g:9625:2: rule__DecimalExp__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_0();
@@ -25912,14 +26068,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__1"
-    // InternalFSM.g:9588:1: rule__DecimalExp__Group__1 : rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ;
+    // InternalFSM.g:9635:1: rule__DecimalExp__Group__1 : rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ;
     public final void rule__DecimalExp__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9592:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 )
-            // InternalFSM.g:9593:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2
+            // InternalFSM.g:9639:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 )
+            // InternalFSM.g:9640:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2
             {
             pushFollow(FOLLOW_51);
             rule__DecimalExp__Group__1__Impl();
@@ -25950,17 +26106,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__1__Impl"
-    // InternalFSM.g:9600:1: rule__DecimalExp__Group__1__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9647:1: rule__DecimalExp__Group__1__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9604:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9605:1: ( RULE_INT )
+            // InternalFSM.g:9651:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9652:1: ( RULE_INT )
             {
-            // InternalFSM.g:9605:1: ( RULE_INT )
-            // InternalFSM.g:9606:1: RULE_INT
+            // InternalFSM.g:9652:1: ( RULE_INT )
+            // InternalFSM.g:9653:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -25987,14 +26143,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__2"
-    // InternalFSM.g:9617:1: rule__DecimalExp__Group__2 : rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ;
+    // InternalFSM.g:9664:1: rule__DecimalExp__Group__2 : rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ;
     public final void rule__DecimalExp__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9621:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 )
-            // InternalFSM.g:9622:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3
+            // InternalFSM.g:9668:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 )
+            // InternalFSM.g:9669:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3
             {
             pushFollow(FOLLOW_52);
             rule__DecimalExp__Group__2__Impl();
@@ -26025,17 +26181,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__2__Impl"
-    // InternalFSM.g:9629:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ;
+    // InternalFSM.g:9676:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ;
     public final void rule__DecimalExp__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9633:1: ( ( '.' ) )
-            // InternalFSM.g:9634:1: ( '.' )
+            // InternalFSM.g:9680:1: ( ( '.' ) )
+            // InternalFSM.g:9681:1: ( '.' )
             {
-            // InternalFSM.g:9634:1: ( '.' )
-            // InternalFSM.g:9635:1: '.'
+            // InternalFSM.g:9681:1: ( '.' )
+            // InternalFSM.g:9682:1: '.'
             {
              before(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); 
             match(input,68,FOLLOW_2); 
@@ -26062,14 +26218,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__3"
-    // InternalFSM.g:9648:1: rule__DecimalExp__Group__3 : rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ;
+    // InternalFSM.g:9695:1: rule__DecimalExp__Group__3 : rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ;
     public final void rule__DecimalExp__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9652:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 )
-            // InternalFSM.g:9653:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4
+            // InternalFSM.g:9699:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 )
+            // InternalFSM.g:9700:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4
             {
             pushFollow(FOLLOW_53);
             rule__DecimalExp__Group__3__Impl();
@@ -26100,17 +26256,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__3__Impl"
-    // InternalFSM.g:9660:1: rule__DecimalExp__Group__3__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9707:1: rule__DecimalExp__Group__3__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9664:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9665:1: ( RULE_INT )
+            // InternalFSM.g:9711:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9712:1: ( RULE_INT )
             {
-            // InternalFSM.g:9665:1: ( RULE_INT )
-            // InternalFSM.g:9666:1: RULE_INT
+            // InternalFSM.g:9712:1: ( RULE_INT )
+            // InternalFSM.g:9713:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -26137,14 +26293,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__4"
-    // InternalFSM.g:9677:1: rule__DecimalExp__Group__4 : rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ;
+    // InternalFSM.g:9724:1: rule__DecimalExp__Group__4 : rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ;
     public final void rule__DecimalExp__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9681:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 )
-            // InternalFSM.g:9682:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5
+            // InternalFSM.g:9728:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 )
+            // InternalFSM.g:9729:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5
             {
             pushFollow(FOLLOW_50);
             rule__DecimalExp__Group__4__Impl();
@@ -26175,21 +26331,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__4__Impl"
-    // InternalFSM.g:9689:1: rule__DecimalExp__Group__4__Impl : ( ( rule__DecimalExp__Alternatives_4 ) ) ;
+    // InternalFSM.g:9736:1: rule__DecimalExp__Group__4__Impl : ( ( rule__DecimalExp__Alternatives_4 ) ) ;
     public final void rule__DecimalExp__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9693:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) )
-            // InternalFSM.g:9694:1: ( ( rule__DecimalExp__Alternatives_4 ) )
+            // InternalFSM.g:9740:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) )
+            // InternalFSM.g:9741:1: ( ( rule__DecimalExp__Alternatives_4 ) )
             {
-            // InternalFSM.g:9694:1: ( ( rule__DecimalExp__Alternatives_4 ) )
-            // InternalFSM.g:9695:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalFSM.g:9741:1: ( ( rule__DecimalExp__Alternatives_4 ) )
+            // InternalFSM.g:9742:1: ( rule__DecimalExp__Alternatives_4 )
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_4()); 
-            // InternalFSM.g:9696:1: ( rule__DecimalExp__Alternatives_4 )
-            // InternalFSM.g:9696:2: rule__DecimalExp__Alternatives_4
+            // InternalFSM.g:9743:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalFSM.g:9743:2: rule__DecimalExp__Alternatives_4
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Alternatives_4();
@@ -26222,14 +26378,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__5"
-    // InternalFSM.g:9706:1: rule__DecimalExp__Group__5 : rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ;
+    // InternalFSM.g:9753:1: rule__DecimalExp__Group__5 : rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ;
     public final void rule__DecimalExp__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9710:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 )
-            // InternalFSM.g:9711:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6
+            // InternalFSM.g:9757:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 )
+            // InternalFSM.g:9758:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6
             {
             pushFollow(FOLLOW_50);
             rule__DecimalExp__Group__5__Impl();
@@ -26260,29 +26416,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__5__Impl"
-    // InternalFSM.g:9718:1: rule__DecimalExp__Group__5__Impl : ( ( rule__DecimalExp__Alternatives_5 )? ) ;
+    // InternalFSM.g:9765:1: rule__DecimalExp__Group__5__Impl : ( ( rule__DecimalExp__Alternatives_5 )? ) ;
     public final void rule__DecimalExp__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9722:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) )
-            // InternalFSM.g:9723:1: ( ( rule__DecimalExp__Alternatives_5 )? )
+            // InternalFSM.g:9769:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) )
+            // InternalFSM.g:9770:1: ( ( rule__DecimalExp__Alternatives_5 )? )
             {
-            // InternalFSM.g:9723:1: ( ( rule__DecimalExp__Alternatives_5 )? )
-            // InternalFSM.g:9724:1: ( rule__DecimalExp__Alternatives_5 )?
+            // InternalFSM.g:9770:1: ( ( rule__DecimalExp__Alternatives_5 )? )
+            // InternalFSM.g:9771:1: ( rule__DecimalExp__Alternatives_5 )?
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_5()); 
-            // InternalFSM.g:9725:1: ( rule__DecimalExp__Alternatives_5 )?
-            int alt79=2;
-            int LA79_0 = input.LA(1);
+            // InternalFSM.g:9772:1: ( rule__DecimalExp__Alternatives_5 )?
+            int alt80=2;
+            int LA80_0 = input.LA(1);
 
-            if ( ((LA79_0>=15 && LA79_0<=16)) ) {
-                alt79=1;
+            if ( ((LA80_0>=15 && LA80_0<=16)) ) {
+                alt80=1;
             }
-            switch (alt79) {
+            switch (alt80) {
                 case 1 :
-                    // InternalFSM.g:9725:2: rule__DecimalExp__Alternatives_5
+                    // InternalFSM.g:9772:2: rule__DecimalExp__Alternatives_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_5();
@@ -26318,14 +26474,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__6"
-    // InternalFSM.g:9735:1: rule__DecimalExp__Group__6 : rule__DecimalExp__Group__6__Impl ;
+    // InternalFSM.g:9782:1: rule__DecimalExp__Group__6 : rule__DecimalExp__Group__6__Impl ;
     public final void rule__DecimalExp__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9739:1: ( rule__DecimalExp__Group__6__Impl )
-            // InternalFSM.g:9740:2: rule__DecimalExp__Group__6__Impl
+            // InternalFSM.g:9786:1: ( rule__DecimalExp__Group__6__Impl )
+            // InternalFSM.g:9787:2: rule__DecimalExp__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__6__Impl();
@@ -26351,17 +26507,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__6__Impl"
-    // InternalFSM.g:9746:1: rule__DecimalExp__Group__6__Impl : ( RULE_INT ) ;
+    // InternalFSM.g:9793:1: rule__DecimalExp__Group__6__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9750:1: ( ( RULE_INT ) )
-            // InternalFSM.g:9751:1: ( RULE_INT )
+            // InternalFSM.g:9797:1: ( ( RULE_INT ) )
+            // InternalFSM.g:9798:1: ( RULE_INT )
             {
-            // InternalFSM.g:9751:1: ( RULE_INT )
-            // InternalFSM.g:9752:1: RULE_INT
+            // InternalFSM.g:9798:1: ( RULE_INT )
+            // InternalFSM.g:9799:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_6()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -26388,14 +26544,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__0"
-    // InternalFSM.g:9777:1: rule__FQN__Group__0 : rule__FQN__Group__0__Impl rule__FQN__Group__1 ;
+    // InternalFSM.g:9824:1: rule__FQN__Group__0 : rule__FQN__Group__0__Impl rule__FQN__Group__1 ;
     public final void rule__FQN__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9781:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 )
-            // InternalFSM.g:9782:2: rule__FQN__Group__0__Impl rule__FQN__Group__1
+            // InternalFSM.g:9828:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 )
+            // InternalFSM.g:9829:2: rule__FQN__Group__0__Impl rule__FQN__Group__1
             {
             pushFollow(FOLLOW_51);
             rule__FQN__Group__0__Impl();
@@ -26426,17 +26582,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__0__Impl"
-    // InternalFSM.g:9789:1: rule__FQN__Group__0__Impl : ( RULE_ID ) ;
+    // InternalFSM.g:9836:1: rule__FQN__Group__0__Impl : ( RULE_ID ) ;
     public final void rule__FQN__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9793:1: ( ( RULE_ID ) )
-            // InternalFSM.g:9794:1: ( RULE_ID )
+            // InternalFSM.g:9840:1: ( ( RULE_ID ) )
+            // InternalFSM.g:9841:1: ( RULE_ID )
             {
-            // InternalFSM.g:9794:1: ( RULE_ID )
-            // InternalFSM.g:9795:1: RULE_ID
+            // InternalFSM.g:9841:1: ( RULE_ID )
+            // InternalFSM.g:9842:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -26463,14 +26619,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__1"
-    // InternalFSM.g:9806:1: rule__FQN__Group__1 : rule__FQN__Group__1__Impl ;
+    // InternalFSM.g:9853:1: rule__FQN__Group__1 : rule__FQN__Group__1__Impl ;
     public final void rule__FQN__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9810:1: ( rule__FQN__Group__1__Impl )
-            // InternalFSM.g:9811:2: rule__FQN__Group__1__Impl
+            // InternalFSM.g:9857:1: ( rule__FQN__Group__1__Impl )
+            // InternalFSM.g:9858:2: rule__FQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__1__Impl();
@@ -26496,33 +26652,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__1__Impl"
-    // InternalFSM.g:9817:1: rule__FQN__Group__1__Impl : ( ( rule__FQN__Group_1__0 )* ) ;
+    // InternalFSM.g:9864:1: rule__FQN__Group__1__Impl : ( ( rule__FQN__Group_1__0 )* ) ;
     public final void rule__FQN__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9821:1: ( ( ( rule__FQN__Group_1__0 )* ) )
-            // InternalFSM.g:9822:1: ( ( rule__FQN__Group_1__0 )* )
+            // InternalFSM.g:9868:1: ( ( ( rule__FQN__Group_1__0 )* ) )
+            // InternalFSM.g:9869:1: ( ( rule__FQN__Group_1__0 )* )
             {
-            // InternalFSM.g:9822:1: ( ( rule__FQN__Group_1__0 )* )
-            // InternalFSM.g:9823:1: ( rule__FQN__Group_1__0 )*
+            // InternalFSM.g:9869:1: ( ( rule__FQN__Group_1__0 )* )
+            // InternalFSM.g:9870:1: ( rule__FQN__Group_1__0 )*
             {
              before(grammarAccess.getFQNAccess().getGroup_1()); 
-            // InternalFSM.g:9824:1: ( rule__FQN__Group_1__0 )*
-            loop80:
+            // InternalFSM.g:9871:1: ( rule__FQN__Group_1__0 )*
+            loop81:
             do {
-                int alt80=2;
-                int LA80_0 = input.LA(1);
+                int alt81=2;
+                int LA81_0 = input.LA(1);
 
-                if ( (LA80_0==68) ) {
-                    alt80=1;
+                if ( (LA81_0==68) ) {
+                    alt81=1;
                 }
 
 
-                switch (alt80) {
+                switch (alt81) {
             	case 1 :
-            	    // InternalFSM.g:9824:2: rule__FQN__Group_1__0
+            	    // InternalFSM.g:9871:2: rule__FQN__Group_1__0
             	    {
             	    pushFollow(FOLLOW_54);
             	    rule__FQN__Group_1__0();
@@ -26534,7 +26690,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop80;
+            	    break loop81;
                 }
             } while (true);
 
@@ -26561,14 +26717,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__0"
-    // InternalFSM.g:9838:1: rule__FQN__Group_1__0 : rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ;
+    // InternalFSM.g:9885:1: rule__FQN__Group_1__0 : rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ;
     public final void rule__FQN__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9842:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 )
-            // InternalFSM.g:9843:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1
+            // InternalFSM.g:9889:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 )
+            // InternalFSM.g:9890:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1
             {
             pushFollow(FOLLOW_5);
             rule__FQN__Group_1__0__Impl();
@@ -26599,17 +26755,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__0__Impl"
-    // InternalFSM.g:9850:1: rule__FQN__Group_1__0__Impl : ( '.' ) ;
+    // InternalFSM.g:9897:1: rule__FQN__Group_1__0__Impl : ( '.' ) ;
     public final void rule__FQN__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9854:1: ( ( '.' ) )
-            // InternalFSM.g:9855:1: ( '.' )
+            // InternalFSM.g:9901:1: ( ( '.' ) )
+            // InternalFSM.g:9902:1: ( '.' )
             {
-            // InternalFSM.g:9855:1: ( '.' )
-            // InternalFSM.g:9856:1: '.'
+            // InternalFSM.g:9902:1: ( '.' )
+            // InternalFSM.g:9903:1: '.'
             {
              before(grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); 
             match(input,68,FOLLOW_2); 
@@ -26636,14 +26792,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__1"
-    // InternalFSM.g:9869:1: rule__FQN__Group_1__1 : rule__FQN__Group_1__1__Impl ;
+    // InternalFSM.g:9916:1: rule__FQN__Group_1__1 : rule__FQN__Group_1__1__Impl ;
     public final void rule__FQN__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9873:1: ( rule__FQN__Group_1__1__Impl )
-            // InternalFSM.g:9874:2: rule__FQN__Group_1__1__Impl
+            // InternalFSM.g:9920:1: ( rule__FQN__Group_1__1__Impl )
+            // InternalFSM.g:9921:2: rule__FQN__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group_1__1__Impl();
@@ -26669,17 +26825,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__1__Impl"
-    // InternalFSM.g:9880:1: rule__FQN__Group_1__1__Impl : ( RULE_ID ) ;
+    // InternalFSM.g:9927:1: rule__FQN__Group_1__1__Impl : ( RULE_ID ) ;
     public final void rule__FQN__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9884:1: ( ( RULE_ID ) )
-            // InternalFSM.g:9885:1: ( RULE_ID )
+            // InternalFSM.g:9931:1: ( ( RULE_ID ) )
+            // InternalFSM.g:9932:1: ( RULE_ID )
             {
-            // InternalFSM.g:9885:1: ( RULE_ID )
-            // InternalFSM.g:9886:1: RULE_ID
+            // InternalFSM.g:9932:1: ( RULE_ID )
+            // InternalFSM.g:9933:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -26706,29 +26862,29 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__UnorderedGroup_0"
-    // InternalFSM.g:9902:1: rule__ModelComponent__UnorderedGroup_0 : ( rule__ModelComponent__UnorderedGroup_0__0 )? ;
+    // InternalFSM.g:9949:1: rule__ModelComponent__UnorderedGroup_0 : ( rule__ModelComponent__UnorderedGroup_0__0 )? ;
     public final void rule__ModelComponent__UnorderedGroup_0() throws RecognitionException {
 
             	int stackSize = keepStackSize();
         		getUnorderedGroupHelper().enter(grammarAccess.getModelComponentAccess().getUnorderedGroup_0());
             
         try {
-            // InternalFSM.g:9907:1: ( ( rule__ModelComponent__UnorderedGroup_0__0 )? )
-            // InternalFSM.g:9908:2: ( rule__ModelComponent__UnorderedGroup_0__0 )?
+            // InternalFSM.g:9954:1: ( ( rule__ModelComponent__UnorderedGroup_0__0 )? )
+            // InternalFSM.g:9955:2: ( rule__ModelComponent__UnorderedGroup_0__0 )?
             {
-            // InternalFSM.g:9908:2: ( rule__ModelComponent__UnorderedGroup_0__0 )?
-            int alt81=2;
-            int LA81_0 = input.LA(1);
+            // InternalFSM.g:9955:2: ( rule__ModelComponent__UnorderedGroup_0__0 )?
+            int alt82=2;
+            int LA82_0 = input.LA(1);
 
-            if ( LA81_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
-                alt81=1;
+            if ( LA82_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
+                alt82=1;
             }
-            else if ( LA81_0 >= 19 && LA81_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
-                alt81=1;
+            else if ( LA82_0 >= 19 && LA82_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
+                alt82=1;
             }
-            switch (alt81) {
+            switch (alt82) {
                 case 1 :
-                    // InternalFSM.g:9908:2: rule__ModelComponent__UnorderedGroup_0__0
+                    // InternalFSM.g:9955:2: rule__ModelComponent__UnorderedGroup_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ModelComponent__UnorderedGroup_0__0();
@@ -26761,44 +26917,44 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__Impl"
-    // InternalFSM.g:9918:1: rule__ModelComponent__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) ;
+    // InternalFSM.g:9965:1: rule__ModelComponent__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) ;
     public final void rule__ModelComponent__UnorderedGroup_0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
         		boolean selected = false;
             
         try {
-            // InternalFSM.g:9923:1: ( ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) )
-            // InternalFSM.g:9924:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) )
+            // InternalFSM.g:9970:1: ( ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) )
+            // InternalFSM.g:9971:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) )
             {
-            // InternalFSM.g:9924:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) )
-            int alt82=2;
-            int LA82_0 = input.LA(1);
+            // InternalFSM.g:9971:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) )
+            int alt83=2;
+            int LA83_0 = input.LA(1);
 
-            if ( LA82_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
-                alt82=1;
+            if ( LA83_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
+                alt83=1;
             }
-            else if ( LA82_0 >= 19 && LA82_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
-                alt82=2;
+            else if ( LA83_0 >= 19 && LA83_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
+                alt83=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 82, 0, input);
+                    new NoViableAltException("", 83, 0, input);
 
                 throw nvae;
             }
-            switch (alt82) {
+            switch (alt83) {
                 case 1 :
-                    // InternalFSM.g:9926:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) )
+                    // InternalFSM.g:9973:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) )
                     {
-                    // InternalFSM.g:9926:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) )
-                    // InternalFSM.g:9927:5: {...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) )
+                    // InternalFSM.g:9973:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) )
+                    // InternalFSM.g:9974:5: {...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) )
                     {
                     if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
                         throw new FailedPredicateException(input, "rule__ModelComponent__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0)");
                     }
-                    // InternalFSM.g:9927:111: ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) )
-                    // InternalFSM.g:9928:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) )
+                    // InternalFSM.g:9974:111: ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) )
+                    // InternalFSM.g:9975:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0);
@@ -26806,12 +26962,12 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
                     	 				  selected = true;
                     	 				
-                    // InternalFSM.g:9934:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) )
-                    // InternalFSM.g:9936:7: ( rule__ModelComponent__AbstractAssignment_0_0 )
+                    // InternalFSM.g:9981:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) )
+                    // InternalFSM.g:9983:7: ( rule__ModelComponent__AbstractAssignment_0_0 )
                     {
                      before(grammarAccess.getModelComponentAccess().getAbstractAssignment_0_0()); 
-                    // InternalFSM.g:9937:7: ( rule__ModelComponent__AbstractAssignment_0_0 )
-                    // InternalFSM.g:9937:8: rule__ModelComponent__AbstractAssignment_0_0
+                    // InternalFSM.g:9984:7: ( rule__ModelComponent__AbstractAssignment_0_0 )
+                    // InternalFSM.g:9984:8: rule__ModelComponent__AbstractAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ModelComponent__AbstractAssignment_0_0();
@@ -26835,16 +26991,16 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:9943:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalFSM.g:9990:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) )
                     {
-                    // InternalFSM.g:9943:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) )
-                    // InternalFSM.g:9944:5: {...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) )
+                    // InternalFSM.g:9990:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalFSM.g:9991:5: {...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) )
                     {
                     if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
                         throw new FailedPredicateException(input, "rule__ModelComponent__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1)");
                     }
-                    // InternalFSM.g:9944:111: ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) )
-                    // InternalFSM.g:9945:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) )
+                    // InternalFSM.g:9991:111: ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) )
+                    // InternalFSM.g:9992:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1);
@@ -26852,12 +27008,12 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
                     	 				  selected = true;
                     	 				
-                    // InternalFSM.g:9951:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) )
-                    // InternalFSM.g:9953:7: ( rule__ModelComponent__CommTypeAssignment_0_1 )
+                    // InternalFSM.g:9998:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) )
+                    // InternalFSM.g:10000:7: ( rule__ModelComponent__CommTypeAssignment_0_1 )
                     {
                      before(grammarAccess.getModelComponentAccess().getCommTypeAssignment_0_1()); 
-                    // InternalFSM.g:9954:7: ( rule__ModelComponent__CommTypeAssignment_0_1 )
-                    // InternalFSM.g:9954:8: rule__ModelComponent__CommTypeAssignment_0_1
+                    // InternalFSM.g:10001:7: ( rule__ModelComponent__CommTypeAssignment_0_1 )
+                    // InternalFSM.g:10001:8: rule__ModelComponent__CommTypeAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ModelComponent__CommTypeAssignment_0_1();
@@ -26904,33 +27060,33 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__0"
-    // InternalFSM.g:9969:1: rule__ModelComponent__UnorderedGroup_0__0 : rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? ;
+    // InternalFSM.g:10016:1: rule__ModelComponent__UnorderedGroup_0__0 : rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? ;
     public final void rule__ModelComponent__UnorderedGroup_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9973:1: ( rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? )
-            // InternalFSM.g:9974:2: rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )?
+            // InternalFSM.g:10020:1: ( rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? )
+            // InternalFSM.g:10021:2: rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )?
             {
             pushFollow(FOLLOW_3);
             rule__ModelComponent__UnorderedGroup_0__Impl();
 
             state._fsp--;
 
-            // InternalFSM.g:9975:2: ( rule__ModelComponent__UnorderedGroup_0__1 )?
-            int alt83=2;
-            int LA83_0 = input.LA(1);
+            // InternalFSM.g:10022:2: ( rule__ModelComponent__UnorderedGroup_0__1 )?
+            int alt84=2;
+            int LA84_0 = input.LA(1);
 
-            if ( LA83_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
-                alt83=1;
+            if ( LA84_0 == 69 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) {
+                alt84=1;
             }
-            else if ( LA83_0 >= 19 && LA83_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
-                alt83=1;
+            else if ( LA84_0 >= 19 && LA84_0 <= 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) {
+                alt84=1;
             }
-            switch (alt83) {
+            switch (alt84) {
                 case 1 :
-                    // InternalFSM.g:9975:2: rule__ModelComponent__UnorderedGroup_0__1
+                    // InternalFSM.g:10022:2: rule__ModelComponent__UnorderedGroup_0__1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ModelComponent__UnorderedGroup_0__1();
@@ -26962,14 +27118,14 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__1"
-    // InternalFSM.g:9982:1: rule__ModelComponent__UnorderedGroup_0__1 : rule__ModelComponent__UnorderedGroup_0__Impl ;
+    // InternalFSM.g:10029:1: rule__ModelComponent__UnorderedGroup_0__1 : rule__ModelComponent__UnorderedGroup_0__Impl ;
     public final void rule__ModelComponent__UnorderedGroup_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:9986:1: ( rule__ModelComponent__UnorderedGroup_0__Impl )
-            // InternalFSM.g:9987:2: rule__ModelComponent__UnorderedGroup_0__Impl
+            // InternalFSM.g:10033:1: ( rule__ModelComponent__UnorderedGroup_0__Impl )
+            // InternalFSM.g:10034:2: rule__ModelComponent__UnorderedGroup_0__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ModelComponent__UnorderedGroup_0__Impl();
@@ -26995,17 +27151,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FSMModel__ComponentsAssignment"
-    // InternalFSM.g:9998:1: rule__FSMModel__ComponentsAssignment : ( ruleModelComponent ) ;
+    // InternalFSM.g:10045:1: rule__FSMModel__ComponentsAssignment : ( ruleModelComponent ) ;
     public final void rule__FSMModel__ComponentsAssignment() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10002:1: ( ( ruleModelComponent ) )
-            // InternalFSM.g:10003:1: ( ruleModelComponent )
+            // InternalFSM.g:10049:1: ( ( ruleModelComponent ) )
+            // InternalFSM.g:10050:1: ( ruleModelComponent )
             {
-            // InternalFSM.g:10003:1: ( ruleModelComponent )
-            // InternalFSM.g:10004:1: ruleModelComponent
+            // InternalFSM.g:10050:1: ( ruleModelComponent )
+            // InternalFSM.g:10051:1: ruleModelComponent
             {
              before(grammarAccess.getFSMModelAccess().getComponentsModelComponentParserRuleCall_0()); 
             pushFollow(FOLLOW_2);
@@ -27036,21 +27192,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__AbstractAssignment_0_0"
-    // InternalFSM.g:10013:1: rule__ModelComponent__AbstractAssignment_0_0 : ( ( 'abstract' ) ) ;
+    // InternalFSM.g:10060:1: rule__ModelComponent__AbstractAssignment_0_0 : ( ( 'abstract' ) ) ;
     public final void rule__ModelComponent__AbstractAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10017:1: ( ( ( 'abstract' ) ) )
-            // InternalFSM.g:10018:1: ( ( 'abstract' ) )
+            // InternalFSM.g:10064:1: ( ( ( 'abstract' ) ) )
+            // InternalFSM.g:10065:1: ( ( 'abstract' ) )
             {
-            // InternalFSM.g:10018:1: ( ( 'abstract' ) )
-            // InternalFSM.g:10019:1: ( 'abstract' )
+            // InternalFSM.g:10065:1: ( ( 'abstract' ) )
+            // InternalFSM.g:10066:1: ( 'abstract' )
             {
              before(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); 
-            // InternalFSM.g:10020:1: ( 'abstract' )
-            // InternalFSM.g:10021:1: 'abstract'
+            // InternalFSM.g:10067:1: ( 'abstract' )
+            // InternalFSM.g:10068:1: 'abstract'
             {
              before(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); 
             match(input,69,FOLLOW_2); 
@@ -27081,17 +27237,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__CommTypeAssignment_0_1"
-    // InternalFSM.g:10036:1: rule__ModelComponent__CommTypeAssignment_0_1 : ( ruleComponentCommunicationType ) ;
+    // InternalFSM.g:10083:1: rule__ModelComponent__CommTypeAssignment_0_1 : ( ruleComponentCommunicationType ) ;
     public final void rule__ModelComponent__CommTypeAssignment_0_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10040:1: ( ( ruleComponentCommunicationType ) )
-            // InternalFSM.g:10041:1: ( ruleComponentCommunicationType )
+            // InternalFSM.g:10087:1: ( ( ruleComponentCommunicationType ) )
+            // InternalFSM.g:10088:1: ( ruleComponentCommunicationType )
             {
-            // InternalFSM.g:10041:1: ( ruleComponentCommunicationType )
-            // InternalFSM.g:10042:1: ruleComponentCommunicationType
+            // InternalFSM.g:10088:1: ( ruleComponentCommunicationType )
+            // InternalFSM.g:10089:1: ruleComponentCommunicationType
             {
              before(grammarAccess.getModelComponentAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27122,17 +27278,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__ComponentNameAssignment_2"
-    // InternalFSM.g:10051:1: rule__ModelComponent__ComponentNameAssignment_2 : ( RULE_ID ) ;
+    // InternalFSM.g:10098:1: rule__ModelComponent__ComponentNameAssignment_2 : ( RULE_ID ) ;
     public final void rule__ModelComponent__ComponentNameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10055:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10056:1: ( RULE_ID )
+            // InternalFSM.g:10102:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10103:1: ( RULE_ID )
             {
-            // InternalFSM.g:10056:1: ( RULE_ID )
-            // InternalFSM.g:10057:1: RULE_ID
+            // InternalFSM.g:10103:1: ( RULE_ID )
+            // InternalFSM.g:10104:1: RULE_ID
             {
              before(grammarAccess.getModelComponentAccess().getComponentNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -27159,21 +27315,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__BaseAssignment_3_1"
-    // InternalFSM.g:10066:1: rule__ModelComponent__BaseAssignment_3_1 : ( ( ruleFQN ) ) ;
+    // InternalFSM.g:10113:1: rule__ModelComponent__BaseAssignment_3_1 : ( ( ruleFQN ) ) ;
     public final void rule__ModelComponent__BaseAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10070:1: ( ( ( ruleFQN ) ) )
-            // InternalFSM.g:10071:1: ( ( ruleFQN ) )
+            // InternalFSM.g:10117:1: ( ( ( ruleFQN ) ) )
+            // InternalFSM.g:10118:1: ( ( ruleFQN ) )
             {
-            // InternalFSM.g:10071:1: ( ( ruleFQN ) )
-            // InternalFSM.g:10072:1: ( ruleFQN )
+            // InternalFSM.g:10118:1: ( ( ruleFQN ) )
+            // InternalFSM.g:10119:1: ( ruleFQN )
             {
              before(grammarAccess.getModelComponentAccess().getBaseModelComponentCrossReference_3_1_0()); 
-            // InternalFSM.g:10073:1: ( ruleFQN )
-            // InternalFSM.g:10074:1: ruleFQN
+            // InternalFSM.g:10120:1: ( ruleFQN )
+            // InternalFSM.g:10121:1: ruleFQN
             {
              before(grammarAccess.getModelComponentAccess().getBaseModelComponentFQNParserRuleCall_3_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -27208,17 +27364,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ModelComponent__StateMachineAssignment_4"
-    // InternalFSM.g:10085:1: rule__ModelComponent__StateMachineAssignment_4 : ( ruleStateMachine ) ;
+    // InternalFSM.g:10132:1: rule__ModelComponent__StateMachineAssignment_4 : ( ruleStateMachine ) ;
     public final void rule__ModelComponent__StateMachineAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10089:1: ( ( ruleStateMachine ) )
-            // InternalFSM.g:10090:1: ( ruleStateMachine )
+            // InternalFSM.g:10136:1: ( ( ruleStateMachine ) )
+            // InternalFSM.g:10137:1: ( ruleStateMachine )
             {
-            // InternalFSM.g:10090:1: ( ruleStateMachine )
-            // InternalFSM.g:10091:1: ruleStateMachine
+            // InternalFSM.g:10137:1: ( ruleStateMachine )
+            // InternalFSM.g:10138:1: ruleStateMachine
             {
              before(grammarAccess.getModelComponentAccess().getStateMachineStateMachineParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -27249,17 +27405,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__StatesAssignment_2_0"
-    // InternalFSM.g:10100:1: rule__StateGraph__StatesAssignment_2_0 : ( ruleState ) ;
+    // InternalFSM.g:10147:1: rule__StateGraph__StatesAssignment_2_0 : ( ruleState ) ;
     public final void rule__StateGraph__StatesAssignment_2_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10104:1: ( ( ruleState ) )
-            // InternalFSM.g:10105:1: ( ruleState )
+            // InternalFSM.g:10151:1: ( ( ruleState ) )
+            // InternalFSM.g:10152:1: ( ruleState )
             {
-            // InternalFSM.g:10105:1: ( ruleState )
-            // InternalFSM.g:10106:1: ruleState
+            // InternalFSM.g:10152:1: ( ruleState )
+            // InternalFSM.g:10153:1: ruleState
             {
              before(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); 
             pushFollow(FOLLOW_2);
@@ -27290,17 +27446,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__TrPointsAssignment_2_1"
-    // InternalFSM.g:10115:1: rule__StateGraph__TrPointsAssignment_2_1 : ( ruleTrPoint ) ;
+    // InternalFSM.g:10162:1: rule__StateGraph__TrPointsAssignment_2_1 : ( ruleTrPoint ) ;
     public final void rule__StateGraph__TrPointsAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10119:1: ( ( ruleTrPoint ) )
-            // InternalFSM.g:10120:1: ( ruleTrPoint )
+            // InternalFSM.g:10166:1: ( ( ruleTrPoint ) )
+            // InternalFSM.g:10167:1: ( ruleTrPoint )
             {
-            // InternalFSM.g:10120:1: ( ruleTrPoint )
-            // InternalFSM.g:10121:1: ruleTrPoint
+            // InternalFSM.g:10167:1: ( ruleTrPoint )
+            // InternalFSM.g:10168:1: ruleTrPoint
             {
              before(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27331,17 +27487,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__ChPointsAssignment_2_2"
-    // InternalFSM.g:10130:1: rule__StateGraph__ChPointsAssignment_2_2 : ( ruleChoicePoint ) ;
+    // InternalFSM.g:10177:1: rule__StateGraph__ChPointsAssignment_2_2 : ( ruleChoicePoint ) ;
     public final void rule__StateGraph__ChPointsAssignment_2_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10134:1: ( ( ruleChoicePoint ) )
-            // InternalFSM.g:10135:1: ( ruleChoicePoint )
+            // InternalFSM.g:10181:1: ( ( ruleChoicePoint ) )
+            // InternalFSM.g:10182:1: ( ruleChoicePoint )
             {
-            // InternalFSM.g:10135:1: ( ruleChoicePoint )
-            // InternalFSM.g:10136:1: ruleChoicePoint
+            // InternalFSM.g:10182:1: ( ruleChoicePoint )
+            // InternalFSM.g:10183:1: ruleChoicePoint
             {
              before(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); 
             pushFollow(FOLLOW_2);
@@ -27372,17 +27528,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__TransitionsAssignment_2_3"
-    // InternalFSM.g:10145:1: rule__StateGraph__TransitionsAssignment_2_3 : ( ruleTransition ) ;
+    // InternalFSM.g:10192:1: rule__StateGraph__TransitionsAssignment_2_3 : ( ruleTransition ) ;
     public final void rule__StateGraph__TransitionsAssignment_2_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10149:1: ( ( ruleTransition ) )
-            // InternalFSM.g:10150:1: ( ruleTransition )
+            // InternalFSM.g:10196:1: ( ( ruleTransition ) )
+            // InternalFSM.g:10197:1: ( ruleTransition )
             {
-            // InternalFSM.g:10150:1: ( ruleTransition )
-            // InternalFSM.g:10151:1: ruleTransition
+            // InternalFSM.g:10197:1: ( ruleTransition )
+            // InternalFSM.g:10198:1: ruleTransition
             {
              before(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); 
             pushFollow(FOLLOW_2);
@@ -27413,17 +27569,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__RefinedTransitionsAssignment_2_4"
-    // InternalFSM.g:10160:1: rule__StateGraph__RefinedTransitionsAssignment_2_4 : ( ruleRefinedTransition ) ;
+    // InternalFSM.g:10207:1: rule__StateGraph__RefinedTransitionsAssignment_2_4 : ( ruleRefinedTransition ) ;
     public final void rule__StateGraph__RefinedTransitionsAssignment_2_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10164:1: ( ( ruleRefinedTransition ) )
-            // InternalFSM.g:10165:1: ( ruleRefinedTransition )
+            // InternalFSM.g:10211:1: ( ( ruleRefinedTransition ) )
+            // InternalFSM.g:10212:1: ( ruleRefinedTransition )
             {
-            // InternalFSM.g:10165:1: ( ruleRefinedTransition )
-            // InternalFSM.g:10166:1: ruleRefinedTransition
+            // InternalFSM.g:10212:1: ( ruleRefinedTransition )
+            // InternalFSM.g:10213:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); 
             pushFollow(FOLLOW_2);
@@ -27454,17 +27610,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__StatesAssignment_3_0"
-    // InternalFSM.g:10175:1: rule__StateMachine__StatesAssignment_3_0 : ( ruleState ) ;
+    // InternalFSM.g:10222:1: rule__StateMachine__StatesAssignment_3_0 : ( ruleState ) ;
     public final void rule__StateMachine__StatesAssignment_3_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10179:1: ( ( ruleState ) )
-            // InternalFSM.g:10180:1: ( ruleState )
+            // InternalFSM.g:10226:1: ( ( ruleState ) )
+            // InternalFSM.g:10227:1: ( ruleState )
             {
-            // InternalFSM.g:10180:1: ( ruleState )
-            // InternalFSM.g:10181:1: ruleState
+            // InternalFSM.g:10227:1: ( ruleState )
+            // InternalFSM.g:10228:1: ruleState
             {
              before(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -27495,17 +27651,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__TrPointsAssignment_3_1"
-    // InternalFSM.g:10190:1: rule__StateMachine__TrPointsAssignment_3_1 : ( ruleTrPoint ) ;
+    // InternalFSM.g:10237:1: rule__StateMachine__TrPointsAssignment_3_1 : ( ruleTrPoint ) ;
     public final void rule__StateMachine__TrPointsAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10194:1: ( ( ruleTrPoint ) )
-            // InternalFSM.g:10195:1: ( ruleTrPoint )
+            // InternalFSM.g:10241:1: ( ( ruleTrPoint ) )
+            // InternalFSM.g:10242:1: ( ruleTrPoint )
             {
-            // InternalFSM.g:10195:1: ( ruleTrPoint )
-            // InternalFSM.g:10196:1: ruleTrPoint
+            // InternalFSM.g:10242:1: ( ruleTrPoint )
+            // InternalFSM.g:10243:1: ruleTrPoint
             {
              before(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27536,17 +27692,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__ChPointsAssignment_3_2"
-    // InternalFSM.g:10205:1: rule__StateMachine__ChPointsAssignment_3_2 : ( ruleChoicePoint ) ;
+    // InternalFSM.g:10252:1: rule__StateMachine__ChPointsAssignment_3_2 : ( ruleChoicePoint ) ;
     public final void rule__StateMachine__ChPointsAssignment_3_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10209:1: ( ( ruleChoicePoint ) )
-            // InternalFSM.g:10210:1: ( ruleChoicePoint )
+            // InternalFSM.g:10256:1: ( ( ruleChoicePoint ) )
+            // InternalFSM.g:10257:1: ( ruleChoicePoint )
             {
-            // InternalFSM.g:10210:1: ( ruleChoicePoint )
-            // InternalFSM.g:10211:1: ruleChoicePoint
+            // InternalFSM.g:10257:1: ( ruleChoicePoint )
+            // InternalFSM.g:10258:1: ruleChoicePoint
             {
              before(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); 
             pushFollow(FOLLOW_2);
@@ -27577,17 +27733,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__TransitionsAssignment_3_3"
-    // InternalFSM.g:10220:1: rule__StateMachine__TransitionsAssignment_3_3 : ( ruleTransition ) ;
+    // InternalFSM.g:10267:1: rule__StateMachine__TransitionsAssignment_3_3 : ( ruleTransition ) ;
     public final void rule__StateMachine__TransitionsAssignment_3_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10224:1: ( ( ruleTransition ) )
-            // InternalFSM.g:10225:1: ( ruleTransition )
+            // InternalFSM.g:10271:1: ( ( ruleTransition ) )
+            // InternalFSM.g:10272:1: ( ruleTransition )
             {
-            // InternalFSM.g:10225:1: ( ruleTransition )
-            // InternalFSM.g:10226:1: ruleTransition
+            // InternalFSM.g:10272:1: ( ruleTransition )
+            // InternalFSM.g:10273:1: ruleTransition
             {
              before(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); 
             pushFollow(FOLLOW_2);
@@ -27618,17 +27774,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__RefinedTransitionsAssignment_3_4"
-    // InternalFSM.g:10235:1: rule__StateMachine__RefinedTransitionsAssignment_3_4 : ( ruleRefinedTransition ) ;
+    // InternalFSM.g:10282:1: rule__StateMachine__RefinedTransitionsAssignment_3_4 : ( ruleRefinedTransition ) ;
     public final void rule__StateMachine__RefinedTransitionsAssignment_3_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10239:1: ( ( ruleRefinedTransition ) )
-            // InternalFSM.g:10240:1: ( ruleRefinedTransition )
+            // InternalFSM.g:10286:1: ( ( ruleRefinedTransition ) )
+            // InternalFSM.g:10287:1: ( ruleRefinedTransition )
             {
-            // InternalFSM.g:10240:1: ( ruleRefinedTransition )
-            // InternalFSM.g:10241:1: ruleRefinedTransition
+            // InternalFSM.g:10287:1: ( ruleRefinedTransition )
+            // InternalFSM.g:10288:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); 
             pushFollow(FOLLOW_2);
@@ -27659,17 +27815,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__NameAssignment_1"
-    // InternalFSM.g:10250:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10297:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SimpleState__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10254:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10255:1: ( RULE_ID )
+            // InternalFSM.g:10301:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10302:1: ( RULE_ID )
             {
-            // InternalFSM.g:10255:1: ( RULE_ID )
-            // InternalFSM.g:10256:1: RULE_ID
+            // InternalFSM.g:10302:1: ( RULE_ID )
+            // InternalFSM.g:10303:1: RULE_ID
             {
              before(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -27696,17 +27852,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__DocuAssignment_2"
-    // InternalFSM.g:10265:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10312:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__SimpleState__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10269:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10270:1: ( ruleDocumentation )
+            // InternalFSM.g:10316:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10317:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10270:1: ( ruleDocumentation )
-            // InternalFSM.g:10271:1: ruleDocumentation
+            // InternalFSM.g:10317:1: ( ruleDocumentation )
+            // InternalFSM.g:10318:1: ruleDocumentation
             {
              before(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -27737,17 +27893,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__EntryCodeAssignment_3_1_1"
-    // InternalFSM.g:10280:1: rule__SimpleState__EntryCodeAssignment_3_1_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10327:1: rule__SimpleState__EntryCodeAssignment_3_1_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__EntryCodeAssignment_3_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10284:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10285:1: ( ruleDetailCode )
+            // InternalFSM.g:10331:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10332:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10285:1: ( ruleDetailCode )
-            // InternalFSM.g:10286:1: ruleDetailCode
+            // InternalFSM.g:10332:1: ( ruleDetailCode )
+            // InternalFSM.g:10333:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27778,17 +27934,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__ExitCodeAssignment_3_2_1"
-    // InternalFSM.g:10295:1: rule__SimpleState__ExitCodeAssignment_3_2_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10342:1: rule__SimpleState__ExitCodeAssignment_3_2_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__ExitCodeAssignment_3_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10299:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10300:1: ( ruleDetailCode )
+            // InternalFSM.g:10346:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10347:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10300:1: ( ruleDetailCode )
-            // InternalFSM.g:10301:1: ruleDetailCode
+            // InternalFSM.g:10347:1: ( ruleDetailCode )
+            // InternalFSM.g:10348:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27819,17 +27975,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__DoCodeAssignment_3_3_1"
-    // InternalFSM.g:10310:1: rule__SimpleState__DoCodeAssignment_3_3_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10357:1: rule__SimpleState__DoCodeAssignment_3_3_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__DoCodeAssignment_3_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10314:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10315:1: ( ruleDetailCode )
+            // InternalFSM.g:10361:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10362:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10315:1: ( ruleDetailCode )
-            // InternalFSM.g:10316:1: ruleDetailCode
+            // InternalFSM.g:10362:1: ( ruleDetailCode )
+            // InternalFSM.g:10363:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27860,17 +28016,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__SubgraphAssignment_3_4_1"
-    // InternalFSM.g:10325:1: rule__SimpleState__SubgraphAssignment_3_4_1 : ( ruleStateGraph ) ;
+    // InternalFSM.g:10372:1: rule__SimpleState__SubgraphAssignment_3_4_1 : ( ruleStateGraph ) ;
     public final void rule__SimpleState__SubgraphAssignment_3_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10329:1: ( ( ruleStateGraph ) )
-            // InternalFSM.g:10330:1: ( ruleStateGraph )
+            // InternalFSM.g:10376:1: ( ( ruleStateGraph ) )
+            // InternalFSM.g:10377:1: ( ruleStateGraph )
             {
-            // InternalFSM.g:10330:1: ( ruleStateGraph )
-            // InternalFSM.g:10331:1: ruleStateGraph
+            // InternalFSM.g:10377:1: ( ruleStateGraph )
+            // InternalFSM.g:10378:1: ruleStateGraph
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -27901,21 +28057,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__TargetAssignment_1"
-    // InternalFSM.g:10340:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalFSM.g:10387:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ;
     public final void rule__RefinedState__TargetAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10344:1: ( ( ( ruleFQN ) ) )
-            // InternalFSM.g:10345:1: ( ( ruleFQN ) )
+            // InternalFSM.g:10391:1: ( ( ( ruleFQN ) ) )
+            // InternalFSM.g:10392:1: ( ( ruleFQN ) )
             {
-            // InternalFSM.g:10345:1: ( ( ruleFQN ) )
-            // InternalFSM.g:10346:1: ( ruleFQN )
+            // InternalFSM.g:10392:1: ( ( ruleFQN ) )
+            // InternalFSM.g:10393:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); 
-            // InternalFSM.g:10347:1: ( ruleFQN )
-            // InternalFSM.g:10348:1: ruleFQN
+            // InternalFSM.g:10394:1: ( ruleFQN )
+            // InternalFSM.g:10395:1: ruleFQN
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -27950,17 +28106,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__DocuAssignment_2"
-    // InternalFSM.g:10359:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10406:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__RefinedState__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10363:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10364:1: ( ruleDocumentation )
+            // InternalFSM.g:10410:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10411:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10364:1: ( ruleDocumentation )
-            // InternalFSM.g:10365:1: ruleDocumentation
+            // InternalFSM.g:10411:1: ( ruleDocumentation )
+            // InternalFSM.g:10412:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -27991,17 +28147,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__EntryCodeAssignment_4_1"
-    // InternalFSM.g:10374:1: rule__RefinedState__EntryCodeAssignment_4_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10421:1: rule__RefinedState__EntryCodeAssignment_4_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__EntryCodeAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10378:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10379:1: ( ruleDetailCode )
+            // InternalFSM.g:10425:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10426:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10379:1: ( ruleDetailCode )
-            // InternalFSM.g:10380:1: ruleDetailCode
+            // InternalFSM.g:10426:1: ( ruleDetailCode )
+            // InternalFSM.g:10427:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28032,17 +28188,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__ExitCodeAssignment_5_1"
-    // InternalFSM.g:10389:1: rule__RefinedState__ExitCodeAssignment_5_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10436:1: rule__RefinedState__ExitCodeAssignment_5_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__ExitCodeAssignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10393:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10394:1: ( ruleDetailCode )
+            // InternalFSM.g:10440:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10441:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10394:1: ( ruleDetailCode )
-            // InternalFSM.g:10395:1: ruleDetailCode
+            // InternalFSM.g:10441:1: ( ruleDetailCode )
+            // InternalFSM.g:10442:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28073,17 +28229,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__DoCodeAssignment_6_1"
-    // InternalFSM.g:10404:1: rule__RefinedState__DoCodeAssignment_6_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10451:1: rule__RefinedState__DoCodeAssignment_6_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__DoCodeAssignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10408:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10409:1: ( ruleDetailCode )
+            // InternalFSM.g:10455:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10456:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10409:1: ( ruleDetailCode )
-            // InternalFSM.g:10410:1: ruleDetailCode
+            // InternalFSM.g:10456:1: ( ruleDetailCode )
+            // InternalFSM.g:10457:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28114,17 +28270,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__SubgraphAssignment_7_1"
-    // InternalFSM.g:10419:1: rule__RefinedState__SubgraphAssignment_7_1 : ( ruleStateGraph ) ;
+    // InternalFSM.g:10466:1: rule__RefinedState__SubgraphAssignment_7_1 : ( ruleStateGraph ) ;
     public final void rule__RefinedState__SubgraphAssignment_7_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10423:1: ( ( ruleStateGraph ) )
-            // InternalFSM.g:10424:1: ( ruleStateGraph )
+            // InternalFSM.g:10470:1: ( ( ruleStateGraph ) )
+            // InternalFSM.g:10471:1: ( ruleStateGraph )
             {
-            // InternalFSM.g:10424:1: ( ruleStateGraph )
-            // InternalFSM.g:10425:1: ruleStateGraph
+            // InternalFSM.g:10471:1: ( ruleStateGraph )
+            // InternalFSM.g:10472:1: ruleStateGraph
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28155,17 +28311,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__LinesAssignment_0_1"
-    // InternalFSM.g:10434:1: rule__DetailCode__LinesAssignment_0_1 : ( RULE_CC_STRING ) ;
+    // InternalFSM.g:10481:1: rule__DetailCode__LinesAssignment_0_1 : ( RULE_CC_STRING ) ;
     public final void rule__DetailCode__LinesAssignment_0_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10438:1: ( ( RULE_CC_STRING ) )
-            // InternalFSM.g:10439:1: ( RULE_CC_STRING )
+            // InternalFSM.g:10485:1: ( ( RULE_CC_STRING ) )
+            // InternalFSM.g:10486:1: ( RULE_CC_STRING )
             {
-            // InternalFSM.g:10439:1: ( RULE_CC_STRING )
-            // InternalFSM.g:10440:1: RULE_CC_STRING
+            // InternalFSM.g:10486:1: ( RULE_CC_STRING )
+            // InternalFSM.g:10487:1: RULE_CC_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesCC_STRINGTerminalRuleCall_0_1_0()); 
             match(input,RULE_CC_STRING,FOLLOW_2); 
@@ -28192,21 +28348,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__UsedAssignment_1_0"
-    // InternalFSM.g:10449:1: rule__DetailCode__UsedAssignment_1_0 : ( ( '{' ) ) ;
+    // InternalFSM.g:10496:1: rule__DetailCode__UsedAssignment_1_0 : ( ( '{' ) ) ;
     public final void rule__DetailCode__UsedAssignment_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10453:1: ( ( ( '{' ) ) )
-            // InternalFSM.g:10454:1: ( ( '{' ) )
+            // InternalFSM.g:10500:1: ( ( ( '{' ) ) )
+            // InternalFSM.g:10501:1: ( ( '{' ) )
             {
-            // InternalFSM.g:10454:1: ( ( '{' ) )
-            // InternalFSM.g:10455:1: ( '{' )
+            // InternalFSM.g:10501:1: ( ( '{' ) )
+            // InternalFSM.g:10502:1: ( '{' )
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
-            // InternalFSM.g:10456:1: ( '{' )
-            // InternalFSM.g:10457:1: '{'
+            // InternalFSM.g:10503:1: ( '{' )
+            // InternalFSM.g:10504:1: '{'
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
             match(input,29,FOLLOW_2); 
@@ -28237,17 +28393,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__LinesAssignment_1_1"
-    // InternalFSM.g:10472:1: rule__DetailCode__LinesAssignment_1_1 : ( RULE_STRING ) ;
+    // InternalFSM.g:10519:1: rule__DetailCode__LinesAssignment_1_1 : ( RULE_STRING ) ;
     public final void rule__DetailCode__LinesAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10476:1: ( ( RULE_STRING ) )
-            // InternalFSM.g:10477:1: ( RULE_STRING )
+            // InternalFSM.g:10523:1: ( ( RULE_STRING ) )
+            // InternalFSM.g:10524:1: ( RULE_STRING )
             {
-            // InternalFSM.g:10477:1: ( RULE_STRING )
-            // InternalFSM.g:10478:1: RULE_STRING
+            // InternalFSM.g:10524:1: ( RULE_STRING )
+            // InternalFSM.g:10525:1: RULE_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_1_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -28274,21 +28430,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__HandlerAssignment_0"
-    // InternalFSM.g:10487:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ;
+    // InternalFSM.g:10534:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ;
     public final void rule__TransitionPoint__HandlerAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10491:1: ( ( ( 'handler' ) ) )
-            // InternalFSM.g:10492:1: ( ( 'handler' ) )
+            // InternalFSM.g:10538:1: ( ( ( 'handler' ) ) )
+            // InternalFSM.g:10539:1: ( ( 'handler' ) )
             {
-            // InternalFSM.g:10492:1: ( ( 'handler' ) )
-            // InternalFSM.g:10493:1: ( 'handler' )
+            // InternalFSM.g:10539:1: ( ( 'handler' ) )
+            // InternalFSM.g:10540:1: ( 'handler' )
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
-            // InternalFSM.g:10494:1: ( 'handler' )
-            // InternalFSM.g:10495:1: 'handler'
+            // InternalFSM.g:10541:1: ( 'handler' )
+            // InternalFSM.g:10542:1: 'handler'
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
             match(input,70,FOLLOW_2); 
@@ -28319,17 +28475,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__NameAssignment_2"
-    // InternalFSM.g:10510:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalFSM.g:10557:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__TransitionPoint__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10514:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10515:1: ( RULE_ID )
+            // InternalFSM.g:10561:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10562:1: ( RULE_ID )
             {
-            // InternalFSM.g:10515:1: ( RULE_ID )
-            // InternalFSM.g:10516:1: RULE_ID
+            // InternalFSM.g:10562:1: ( RULE_ID )
+            // InternalFSM.g:10563:1: RULE_ID
             {
              before(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28356,17 +28512,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__NameAssignment_1"
-    // InternalFSM.g:10525:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10572:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__EntryPoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10529:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10530:1: ( RULE_ID )
+            // InternalFSM.g:10576:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10577:1: ( RULE_ID )
             {
-            // InternalFSM.g:10530:1: ( RULE_ID )
-            // InternalFSM.g:10531:1: RULE_ID
+            // InternalFSM.g:10577:1: ( RULE_ID )
+            // InternalFSM.g:10578:1: RULE_ID
             {
              before(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28393,17 +28549,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__NameAssignment_1"
-    // InternalFSM.g:10540:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10587:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ExitPoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10544:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10545:1: ( RULE_ID )
+            // InternalFSM.g:10591:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10592:1: ( RULE_ID )
             {
-            // InternalFSM.g:10545:1: ( RULE_ID )
-            // InternalFSM.g:10546:1: RULE_ID
+            // InternalFSM.g:10592:1: ( RULE_ID )
+            // InternalFSM.g:10593:1: RULE_ID
             {
              before(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28430,17 +28586,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__NameAssignment_1"
-    // InternalFSM.g:10555:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10602:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ChoicePoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10559:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10560:1: ( RULE_ID )
+            // InternalFSM.g:10606:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10607:1: ( RULE_ID )
             {
-            // InternalFSM.g:10560:1: ( RULE_ID )
-            // InternalFSM.g:10561:1: RULE_ID
+            // InternalFSM.g:10607:1: ( RULE_ID )
+            // InternalFSM.g:10608:1: RULE_ID
             {
              before(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28467,17 +28623,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__DocuAssignment_2"
-    // InternalFSM.g:10570:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10617:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__ChoicePoint__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10574:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10575:1: ( ruleDocumentation )
+            // InternalFSM.g:10621:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10622:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10575:1: ( ruleDocumentation )
-            // InternalFSM.g:10576:1: ruleDocumentation
+            // InternalFSM.g:10622:1: ( ruleDocumentation )
+            // InternalFSM.g:10623:1: ruleDocumentation
             {
              before(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -28508,17 +28664,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__NameAssignment_1"
-    // InternalFSM.g:10585:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10632:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__InitialTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10589:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10590:1: ( RULE_ID )
+            // InternalFSM.g:10636:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10637:1: ( RULE_ID )
             {
-            // InternalFSM.g:10590:1: ( RULE_ID )
-            // InternalFSM.g:10591:1: RULE_ID
+            // InternalFSM.g:10637:1: ( RULE_ID )
+            // InternalFSM.g:10638:1: RULE_ID
             {
              before(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28545,17 +28701,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__ToAssignment_5"
-    // InternalFSM.g:10600:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10647:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__InitialTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10604:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10605:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10651:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10652:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10605:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10606:1: ruleTransitionTerminal
+            // InternalFSM.g:10652:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10653:1: ruleTransitionTerminal
             {
              before(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -28586,17 +28742,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__DocuAssignment_6"
-    // InternalFSM.g:10615:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10662:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__InitialTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10619:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10620:1: ( ruleDocumentation )
+            // InternalFSM.g:10666:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10667:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10620:1: ( ruleDocumentation )
-            // InternalFSM.g:10621:1: ruleDocumentation
+            // InternalFSM.g:10667:1: ( ruleDocumentation )
+            // InternalFSM.g:10668:1: ruleDocumentation
             {
              before(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -28627,17 +28783,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__ActionAssignment_7_1_1"
-    // InternalFSM.g:10630:1: rule__InitialTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10677:1: rule__InitialTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
     public final void rule__InitialTransition__ActionAssignment_7_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10634:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10635:1: ( ruleDetailCode )
+            // InternalFSM.g:10681:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10682:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10635:1: ( ruleDetailCode )
-            // InternalFSM.g:10636:1: ruleDetailCode
+            // InternalFSM.g:10682:1: ( ruleDetailCode )
+            // InternalFSM.g:10683:1: ruleDetailCode
             {
              before(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28668,17 +28824,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__NameAssignment_1"
-    // InternalFSM.g:10645:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10692:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ContinuationTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10649:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10650:1: ( RULE_ID )
+            // InternalFSM.g:10696:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10697:1: ( RULE_ID )
             {
-            // InternalFSM.g:10650:1: ( RULE_ID )
-            // InternalFSM.g:10651:1: RULE_ID
+            // InternalFSM.g:10697:1: ( RULE_ID )
+            // InternalFSM.g:10698:1: RULE_ID
             {
              before(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28705,17 +28861,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__FromAssignment_3"
-    // InternalFSM.g:10660:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10707:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__ContinuationTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10664:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10665:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10711:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10712:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10665:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10666:1: ruleTransitionTerminal
+            // InternalFSM.g:10712:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10713:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -28746,17 +28902,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__ToAssignment_5"
-    // InternalFSM.g:10675:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10722:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__ContinuationTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10679:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10680:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10726:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10727:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10680:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10681:1: ruleTransitionTerminal
+            // InternalFSM.g:10727:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10728:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -28787,17 +28943,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__DocuAssignment_6"
-    // InternalFSM.g:10690:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10737:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__ContinuationTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10694:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10695:1: ( ruleDocumentation )
+            // InternalFSM.g:10741:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10742:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10695:1: ( ruleDocumentation )
-            // InternalFSM.g:10696:1: ruleDocumentation
+            // InternalFSM.g:10742:1: ( ruleDocumentation )
+            // InternalFSM.g:10743:1: ruleDocumentation
             {
              before(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -28828,17 +28984,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__ActionAssignment_7_1_1"
-    // InternalFSM.g:10705:1: rule__ContinuationTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10752:1: rule__ContinuationTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
     public final void rule__ContinuationTransition__ActionAssignment_7_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10709:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10710:1: ( ruleDetailCode )
+            // InternalFSM.g:10756:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10757:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10710:1: ( ruleDetailCode )
-            // InternalFSM.g:10711:1: ruleDetailCode
+            // InternalFSM.g:10757:1: ( ruleDetailCode )
+            // InternalFSM.g:10758:1: ruleDetailCode
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -28869,17 +29025,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__NameAssignment_1"
-    // InternalFSM.g:10720:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10767:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__TriggeredTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10724:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10725:1: ( RULE_ID )
+            // InternalFSM.g:10771:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10772:1: ( RULE_ID )
             {
-            // InternalFSM.g:10725:1: ( RULE_ID )
-            // InternalFSM.g:10726:1: RULE_ID
+            // InternalFSM.g:10772:1: ( RULE_ID )
+            // InternalFSM.g:10773:1: RULE_ID
             {
              before(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -28906,17 +29062,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__FromAssignment_3"
-    // InternalFSM.g:10735:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10782:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__TriggeredTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10739:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10740:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10786:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10787:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10740:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10741:1: ruleTransitionTerminal
+            // InternalFSM.g:10787:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10788:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -28947,17 +29103,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__ToAssignment_5"
-    // InternalFSM.g:10750:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10797:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__TriggeredTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10754:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10755:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10801:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10802:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10755:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10756:1: ruleTransitionTerminal
+            // InternalFSM.g:10802:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10803:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -28988,17 +29144,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__DocuAssignment_6"
-    // InternalFSM.g:10765:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10812:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__TriggeredTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10769:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10770:1: ( ruleDocumentation )
+            // InternalFSM.g:10816:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10817:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10770:1: ( ruleDocumentation )
-            // InternalFSM.g:10771:1: ruleDocumentation
+            // InternalFSM.g:10817:1: ( ruleDocumentation )
+            // InternalFSM.g:10818:1: ruleDocumentation
             {
              before(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -29029,17 +29185,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_10"
-    // InternalFSM.g:10780:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ;
+    // InternalFSM.g:10827:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ;
     public final void rule__TriggeredTransition__TriggersAssignment_10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10784:1: ( ( ruleTrigger ) )
-            // InternalFSM.g:10785:1: ( ruleTrigger )
+            // InternalFSM.g:10831:1: ( ( ruleTrigger ) )
+            // InternalFSM.g:10832:1: ( ruleTrigger )
             {
-            // InternalFSM.g:10785:1: ( ruleTrigger )
-            // InternalFSM.g:10786:1: ruleTrigger
+            // InternalFSM.g:10832:1: ( ruleTrigger )
+            // InternalFSM.g:10833:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
             pushFollow(FOLLOW_2);
@@ -29070,17 +29226,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_11_1"
-    // InternalFSM.g:10795:1: rule__TriggeredTransition__TriggersAssignment_11_1 : ( ruleTrigger ) ;
+    // InternalFSM.g:10842:1: rule__TriggeredTransition__TriggersAssignment_11_1 : ( ruleTrigger ) ;
     public final void rule__TriggeredTransition__TriggersAssignment_11_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10799:1: ( ( ruleTrigger ) )
-            // InternalFSM.g:10800:1: ( ruleTrigger )
+            // InternalFSM.g:10846:1: ( ( ruleTrigger ) )
+            // InternalFSM.g:10847:1: ( ruleTrigger )
             {
-            // InternalFSM.g:10800:1: ( ruleTrigger )
-            // InternalFSM.g:10801:1: ruleTrigger
+            // InternalFSM.g:10847:1: ( ruleTrigger )
+            // InternalFSM.g:10848:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
             pushFollow(FOLLOW_2);
@@ -29111,17 +29267,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__ActionAssignment_13_1"
-    // InternalFSM.g:10810:1: rule__TriggeredTransition__ActionAssignment_13_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10857:1: rule__TriggeredTransition__ActionAssignment_13_1 : ( ruleDetailCode ) ;
     public final void rule__TriggeredTransition__ActionAssignment_13_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10814:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10815:1: ( ruleDetailCode )
+            // InternalFSM.g:10861:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10862:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10815:1: ( ruleDetailCode )
-            // InternalFSM.g:10816:1: ruleDetailCode
+            // InternalFSM.g:10862:1: ( ruleDetailCode )
+            // InternalFSM.g:10863:1: ruleDetailCode
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
             pushFollow(FOLLOW_2);
@@ -29152,17 +29308,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__NameAssignment_1"
-    // InternalFSM.g:10825:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10872:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__GuardedTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10829:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10830:1: ( RULE_ID )
+            // InternalFSM.g:10876:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10877:1: ( RULE_ID )
             {
-            // InternalFSM.g:10830:1: ( RULE_ID )
-            // InternalFSM.g:10831:1: RULE_ID
+            // InternalFSM.g:10877:1: ( RULE_ID )
+            // InternalFSM.g:10878:1: RULE_ID
             {
              before(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29189,17 +29345,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__FromAssignment_3"
-    // InternalFSM.g:10840:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10887:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__GuardedTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10844:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10845:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10891:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10892:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10845:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10846:1: ruleTransitionTerminal
+            // InternalFSM.g:10892:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10893:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -29230,17 +29386,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__ToAssignment_5"
-    // InternalFSM.g:10855:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10902:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__GuardedTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10859:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10860:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10906:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10907:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10860:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10861:1: ruleTransitionTerminal
+            // InternalFSM.g:10907:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10908:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -29271,17 +29427,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__DocuAssignment_6"
-    // InternalFSM.g:10870:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalFSM.g:10917:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__GuardedTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10874:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10875:1: ( ruleDocumentation )
+            // InternalFSM.g:10921:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:10922:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10875:1: ( ruleDocumentation )
-            // InternalFSM.g:10876:1: ruleDocumentation
+            // InternalFSM.g:10922:1: ( ruleDocumentation )
+            // InternalFSM.g:10923:1: ruleDocumentation
             {
              before(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -29312,17 +29468,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__GuardAssignment_9"
-    // InternalFSM.g:10885:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10932:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ;
     public final void rule__GuardedTransition__GuardAssignment_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10889:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10890:1: ( ruleDetailCode )
+            // InternalFSM.g:10936:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10937:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10890:1: ( ruleDetailCode )
-            // InternalFSM.g:10891:1: ruleDetailCode
+            // InternalFSM.g:10937:1: ( ruleDetailCode )
+            // InternalFSM.g:10938:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -29353,17 +29509,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__ActionAssignment_10_1"
-    // InternalFSM.g:10900:1: rule__GuardedTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:10947:1: rule__GuardedTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
     public final void rule__GuardedTransition__ActionAssignment_10_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10904:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10905:1: ( ruleDetailCode )
+            // InternalFSM.g:10951:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:10952:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10905:1: ( ruleDetailCode )
-            // InternalFSM.g:10906:1: ruleDetailCode
+            // InternalFSM.g:10952:1: ( ruleDetailCode )
+            // InternalFSM.g:10953:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -29394,17 +29550,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__NameAssignment_1"
-    // InternalFSM.g:10915:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalFSM.g:10962:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__CPBranchTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10919:1: ( ( RULE_ID ) )
-            // InternalFSM.g:10920:1: ( RULE_ID )
+            // InternalFSM.g:10966:1: ( ( RULE_ID ) )
+            // InternalFSM.g:10967:1: ( RULE_ID )
             {
-            // InternalFSM.g:10920:1: ( RULE_ID )
-            // InternalFSM.g:10921:1: RULE_ID
+            // InternalFSM.g:10967:1: ( RULE_ID )
+            // InternalFSM.g:10968:1: RULE_ID
             {
              before(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29431,17 +29587,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__FromAssignment_3"
-    // InternalFSM.g:10930:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10977:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__CPBranchTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10934:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10935:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10981:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10982:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10935:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10936:1: ruleTransitionTerminal
+            // InternalFSM.g:10982:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10983:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -29472,17 +29628,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ToAssignment_5"
-    // InternalFSM.g:10945:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalFSM.g:10992:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__CPBranchTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10949:1: ( ( ruleTransitionTerminal ) )
-            // InternalFSM.g:10950:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10996:1: ( ( ruleTransitionTerminal ) )
+            // InternalFSM.g:10997:1: ( ruleTransitionTerminal )
             {
-            // InternalFSM.g:10950:1: ( ruleTransitionTerminal )
-            // InternalFSM.g:10951:1: ruleTransitionTerminal
+            // InternalFSM.g:10997:1: ( ruleTransitionTerminal )
+            // InternalFSM.g:10998:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -29513,17 +29669,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__DocuAssignment_6"
-    // InternalFSM.g:10960:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalFSM.g:11007:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__CPBranchTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10964:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:10965:1: ( ruleDocumentation )
+            // InternalFSM.g:11011:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:11012:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:10965:1: ( ruleDocumentation )
-            // InternalFSM.g:10966:1: ruleDocumentation
+            // InternalFSM.g:11012:1: ( ruleDocumentation )
+            // InternalFSM.g:11013:1: ruleDocumentation
             {
              before(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -29554,17 +29710,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ConditionAssignment_9"
-    // InternalFSM.g:10975:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ;
+    // InternalFSM.g:11022:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ;
     public final void rule__CPBranchTransition__ConditionAssignment_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10979:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10980:1: ( ruleDetailCode )
+            // InternalFSM.g:11026:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:11027:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10980:1: ( ruleDetailCode )
-            // InternalFSM.g:10981:1: ruleDetailCode
+            // InternalFSM.g:11027:1: ( ruleDetailCode )
+            // InternalFSM.g:11028:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -29595,17 +29751,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ActionAssignment_10_1"
-    // InternalFSM.g:10990:1: rule__CPBranchTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:11037:1: rule__CPBranchTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
     public final void rule__CPBranchTransition__ActionAssignment_10_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:10994:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:10995:1: ( ruleDetailCode )
+            // InternalFSM.g:11041:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:11042:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:10995:1: ( ruleDetailCode )
-            // InternalFSM.g:10996:1: ruleDetailCode
+            // InternalFSM.g:11042:1: ( ruleDetailCode )
+            // InternalFSM.g:11043:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -29636,21 +29792,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__TargetAssignment_1"
-    // InternalFSM.g:11005:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalFSM.g:11052:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ;
     public final void rule__RefinedTransition__TargetAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11009:1: ( ( ( ruleFQN ) ) )
-            // InternalFSM.g:11010:1: ( ( ruleFQN ) )
+            // InternalFSM.g:11056:1: ( ( ( ruleFQN ) ) )
+            // InternalFSM.g:11057:1: ( ( ruleFQN ) )
             {
-            // InternalFSM.g:11010:1: ( ( ruleFQN ) )
-            // InternalFSM.g:11011:1: ( ruleFQN )
+            // InternalFSM.g:11057:1: ( ( ruleFQN ) )
+            // InternalFSM.g:11058:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); 
-            // InternalFSM.g:11012:1: ( ruleFQN )
-            // InternalFSM.g:11013:1: ruleFQN
+            // InternalFSM.g:11059:1: ( ruleFQN )
+            // InternalFSM.g:11060:1: ruleFQN
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -29685,17 +29841,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__DocuAssignment_2"
-    // InternalFSM.g:11024:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalFSM.g:11071:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__RefinedTransition__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11028:1: ( ( ruleDocumentation ) )
-            // InternalFSM.g:11029:1: ( ruleDocumentation )
+            // InternalFSM.g:11075:1: ( ( ruleDocumentation ) )
+            // InternalFSM.g:11076:1: ( ruleDocumentation )
             {
-            // InternalFSM.g:11029:1: ( ruleDocumentation )
-            // InternalFSM.g:11030:1: ruleDocumentation
+            // InternalFSM.g:11076:1: ( ruleDocumentation )
+            // InternalFSM.g:11077:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -29726,17 +29882,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__ActionAssignment_5"
-    // InternalFSM.g:11039:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ;
+    // InternalFSM.g:11086:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ;
     public final void rule__RefinedTransition__ActionAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11043:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:11044:1: ( ruleDetailCode )
+            // InternalFSM.g:11090:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:11091:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:11044:1: ( ruleDetailCode )
-            // InternalFSM.g:11045:1: ruleDetailCode
+            // InternalFSM.g:11091:1: ( ruleDetailCode )
+            // InternalFSM.g:11092:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -29767,21 +29923,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateTerminal__StateAssignment"
-    // InternalFSM.g:11054:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11101:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ;
     public final void rule__StateTerminal__StateAssignment() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11058:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11059:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11105:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11106:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11059:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11060:1: ( RULE_ID )
+            // InternalFSM.g:11106:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11107:1: ( RULE_ID )
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); 
-            // InternalFSM.g:11061:1: ( RULE_ID )
-            // InternalFSM.g:11062:1: RULE_ID
+            // InternalFSM.g:11108:1: ( RULE_ID )
+            // InternalFSM.g:11109:1: RULE_ID
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29812,21 +29968,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__TrPointAssignment_1"
-    // InternalFSM.g:11073:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11120:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__TrPointTerminal__TrPointAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11077:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11078:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11124:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11125:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11078:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11079:1: ( RULE_ID )
+            // InternalFSM.g:11125:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11126:1: ( RULE_ID )
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); 
-            // InternalFSM.g:11080:1: ( RULE_ID )
-            // InternalFSM.g:11081:1: RULE_ID
+            // InternalFSM.g:11127:1: ( RULE_ID )
+            // InternalFSM.g:11128:1: RULE_ID
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29857,21 +30013,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__TrPointAssignment_0"
-    // InternalFSM.g:11092:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11139:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ;
     public final void rule__SubStateTrPointTerminal__TrPointAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11096:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11097:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11143:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11144:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11097:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11098:1: ( RULE_ID )
+            // InternalFSM.g:11144:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11145:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); 
-            // InternalFSM.g:11099:1: ( RULE_ID )
-            // InternalFSM.g:11100:1: RULE_ID
+            // InternalFSM.g:11146:1: ( RULE_ID )
+            // InternalFSM.g:11147:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29902,21 +30058,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__StateAssignment_2"
-    // InternalFSM.g:11111:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11158:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__SubStateTrPointTerminal__StateAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11115:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11116:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11162:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11163:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11116:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11117:1: ( RULE_ID )
+            // InternalFSM.g:11163:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11164:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); 
-            // InternalFSM.g:11118:1: ( RULE_ID )
-            // InternalFSM.g:11119:1: RULE_ID
+            // InternalFSM.g:11165:1: ( RULE_ID )
+            // InternalFSM.g:11166:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29947,21 +30103,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__CpAssignment_1"
-    // InternalFSM.g:11130:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11177:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__ChoicepointTerminal__CpAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11134:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11135:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11181:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11182:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11135:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11136:1: ( RULE_ID )
+            // InternalFSM.g:11182:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11183:1: ( RULE_ID )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); 
-            // InternalFSM.g:11137:1: ( RULE_ID )
-            // InternalFSM.g:11138:1: RULE_ID
+            // InternalFSM.g:11184:1: ( RULE_ID )
+            // InternalFSM.g:11185:1: RULE_ID
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -29992,17 +30148,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_1"
-    // InternalFSM.g:11149:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ;
+    // InternalFSM.g:11196:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ;
     public final void rule__Trigger__MsgFromIfPairsAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11153:1: ( ( ruleMessageFromIf ) )
-            // InternalFSM.g:11154:1: ( ruleMessageFromIf )
+            // InternalFSM.g:11200:1: ( ( ruleMessageFromIf ) )
+            // InternalFSM.g:11201:1: ( ruleMessageFromIf )
             {
-            // InternalFSM.g:11154:1: ( ruleMessageFromIf )
-            // InternalFSM.g:11155:1: ruleMessageFromIf
+            // InternalFSM.g:11201:1: ( ruleMessageFromIf )
+            // InternalFSM.g:11202:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30033,17 +30189,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_2_1"
-    // InternalFSM.g:11164:1: rule__Trigger__MsgFromIfPairsAssignment_2_1 : ( ruleMessageFromIf ) ;
+    // InternalFSM.g:11211:1: rule__Trigger__MsgFromIfPairsAssignment_2_1 : ( ruleMessageFromIf ) ;
     public final void rule__Trigger__MsgFromIfPairsAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11168:1: ( ( ruleMessageFromIf ) )
-            // InternalFSM.g:11169:1: ( ruleMessageFromIf )
+            // InternalFSM.g:11215:1: ( ( ruleMessageFromIf ) )
+            // InternalFSM.g:11216:1: ( ruleMessageFromIf )
             {
-            // InternalFSM.g:11169:1: ( ruleMessageFromIf )
-            // InternalFSM.g:11170:1: ruleMessageFromIf
+            // InternalFSM.g:11216:1: ( ruleMessageFromIf )
+            // InternalFSM.g:11217:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30074,17 +30230,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__GuardAssignment_3"
-    // InternalFSM.g:11179:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ;
+    // InternalFSM.g:11226:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ;
     public final void rule__Trigger__GuardAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11183:1: ( ( ruleGuard ) )
-            // InternalFSM.g:11184:1: ( ruleGuard )
+            // InternalFSM.g:11230:1: ( ( ruleGuard ) )
+            // InternalFSM.g:11231:1: ( ruleGuard )
             {
-            // InternalFSM.g:11184:1: ( ruleGuard )
-            // InternalFSM.g:11185:1: ruleGuard
+            // InternalFSM.g:11231:1: ( ruleGuard )
+            // InternalFSM.g:11232:1: ruleGuard
             {
              before(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -30115,21 +30271,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__MessageAssignment_0"
-    // InternalFSM.g:11194:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11241:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ;
     public final void rule__MessageFromIf__MessageAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11198:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11199:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11245:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11246:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11199:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11200:1: ( RULE_ID )
+            // InternalFSM.g:11246:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11247:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); 
-            // InternalFSM.g:11201:1: ( RULE_ID )
-            // InternalFSM.g:11202:1: RULE_ID
+            // InternalFSM.g:11248:1: ( RULE_ID )
+            // InternalFSM.g:11249:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30160,21 +30316,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__FromAssignment_2"
-    // InternalFSM.g:11213:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11260:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__MessageFromIf__FromAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11217:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11218:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11264:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11265:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11218:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11219:1: ( RULE_ID )
+            // InternalFSM.g:11265:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11266:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); 
-            // InternalFSM.g:11220:1: ( RULE_ID )
-            // InternalFSM.g:11221:1: RULE_ID
+            // InternalFSM.g:11267:1: ( RULE_ID )
+            // InternalFSM.g:11268:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30205,17 +30361,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__GuardAssignment_1"
-    // InternalFSM.g:11233:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ;
+    // InternalFSM.g:11280:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ;
     public final void rule__Guard__GuardAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11237:1: ( ( ruleDetailCode ) )
-            // InternalFSM.g:11238:1: ( ruleDetailCode )
+            // InternalFSM.g:11284:1: ( ( ruleDetailCode ) )
+            // InternalFSM.g:11285:1: ( ruleDetailCode )
             {
-            // InternalFSM.g:11238:1: ( ruleDetailCode )
-            // InternalFSM.g:11239:1: ruleDetailCode
+            // InternalFSM.g:11285:1: ( ruleDetailCode )
+            // InternalFSM.g:11286:1: ruleDetailCode
             {
              before(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30246,21 +30402,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__MsgAssignment_2"
-    // InternalFSM.g:11249:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11296:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__InSemanticsRule__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11253:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11254:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11300:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11301:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11254:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11255:1: ( RULE_ID )
+            // InternalFSM.g:11301:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11302:1: ( RULE_ID )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalFSM.g:11256:1: ( RULE_ID )
-            // InternalFSM.g:11257:1: RULE_ID
+            // InternalFSM.g:11303:1: ( RULE_ID )
+            // InternalFSM.g:11304:1: RULE_ID
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30291,17 +30447,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_0"
-    // InternalFSM.g:11268:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11315:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11272:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11273:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11319:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11320:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11273:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11274:1: ruleSemanticsRule
+            // InternalFSM.g:11320:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11321:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -30332,17 +30488,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1"
-    // InternalFSM.g:11283:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11330:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11287:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11288:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11334:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11335:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11288:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11289:1: ruleSemanticsRule
+            // InternalFSM.g:11335:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11336:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30373,17 +30529,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1"
-    // InternalFSM.g:11298:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11345:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11302:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11303:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11349:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11350:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11303:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11304:1: ruleSemanticsRule
+            // InternalFSM.g:11350:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11351:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30414,21 +30570,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__MsgAssignment_2"
-    // InternalFSM.g:11313:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalFSM.g:11360:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__OutSemanticsRule__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11317:1: ( ( ( RULE_ID ) ) )
-            // InternalFSM.g:11318:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11364:1: ( ( ( RULE_ID ) ) )
+            // InternalFSM.g:11365:1: ( ( RULE_ID ) )
             {
-            // InternalFSM.g:11318:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11319:1: ( RULE_ID )
+            // InternalFSM.g:11365:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11366:1: ( RULE_ID )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalFSM.g:11320:1: ( RULE_ID )
-            // InternalFSM.g:11321:1: RULE_ID
+            // InternalFSM.g:11367:1: ( RULE_ID )
+            // InternalFSM.g:11368:1: RULE_ID
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30459,17 +30615,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_0"
-    // InternalFSM.g:11332:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11379:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11336:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11337:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11383:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11384:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11337:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11338:1: ruleSemanticsRule
+            // InternalFSM.g:11384:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11385:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -30500,17 +30656,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1"
-    // InternalFSM.g:11347:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11394:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11351:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11352:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11398:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11399:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11352:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11353:1: ruleSemanticsRule
+            // InternalFSM.g:11399:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11400:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30541,17 +30697,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1"
-    // InternalFSM.g:11362:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
+    // InternalFSM.g:11409:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11366:1: ( ( ruleSemanticsRule ) )
-            // InternalFSM.g:11367:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11413:1: ( ( ruleSemanticsRule ) )
+            // InternalFSM.g:11414:1: ( ruleSemanticsRule )
             {
-            // InternalFSM.g:11367:1: ( ruleSemanticsRule )
-            // InternalFSM.g:11368:1: ruleSemanticsRule
+            // InternalFSM.g:11414:1: ( ruleSemanticsRule )
+            // InternalFSM.g:11415:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -30582,17 +30738,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__KeyAssignment_0"
-    // InternalFSM.g:11380:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ;
+    // InternalFSM.g:11427:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ;
     public final void rule__KeyValue__KeyAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11384:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11385:1: ( RULE_ID )
+            // InternalFSM.g:11431:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11432:1: ( RULE_ID )
             {
-            // InternalFSM.g:11385:1: ( RULE_ID )
-            // InternalFSM.g:11386:1: RULE_ID
+            // InternalFSM.g:11432:1: ( RULE_ID )
+            // InternalFSM.g:11433:1: RULE_ID
             {
              before(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30619,17 +30775,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__ValueAssignment_2"
-    // InternalFSM.g:11395:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ;
+    // InternalFSM.g:11442:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ;
     public final void rule__KeyValue__ValueAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11399:1: ( ( ruleLiteral ) )
-            // InternalFSM.g:11400:1: ( ruleLiteral )
+            // InternalFSM.g:11446:1: ( ( ruleLiteral ) )
+            // InternalFSM.g:11447:1: ( ruleLiteral )
             {
-            // InternalFSM.g:11400:1: ( ruleLiteral )
-            // InternalFSM.g:11401:1: ruleLiteral
+            // InternalFSM.g:11447:1: ( ruleLiteral )
+            // InternalFSM.g:11448:1: ruleLiteral
             {
              before(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -30660,21 +30816,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__OptionalAssignment_0_0"
-    // InternalFSM.g:11416:1: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
+    // InternalFSM.g:11463:1: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
     public final void rule__SimpleAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11420:1: ( ( ( 'optional' ) ) )
-            // InternalFSM.g:11421:1: ( ( 'optional' ) )
+            // InternalFSM.g:11467:1: ( ( ( 'optional' ) ) )
+            // InternalFSM.g:11468:1: ( ( 'optional' ) )
             {
-            // InternalFSM.g:11421:1: ( ( 'optional' ) )
-            // InternalFSM.g:11422:1: ( 'optional' )
+            // InternalFSM.g:11468:1: ( ( 'optional' ) )
+            // InternalFSM.g:11469:1: ( 'optional' )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalFSM.g:11423:1: ( 'optional' )
-            // InternalFSM.g:11424:1: 'optional'
+            // InternalFSM.g:11470:1: ( 'optional' )
+            // InternalFSM.g:11471:1: 'optional'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,71,FOLLOW_2); 
@@ -30705,17 +30861,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__NameAssignment_2"
-    // InternalFSM.g:11439:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalFSM.g:11486:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__SimpleAnnotationAttribute__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11443:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11444:1: ( RULE_ID )
+            // InternalFSM.g:11490:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11491:1: ( RULE_ID )
             {
-            // InternalFSM.g:11444:1: ( RULE_ID )
-            // InternalFSM.g:11445:1: RULE_ID
+            // InternalFSM.g:11491:1: ( RULE_ID )
+            // InternalFSM.g:11492:1: RULE_ID
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30742,17 +30898,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__TypeAssignment_4"
-    // InternalFSM.g:11454:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ;
+    // InternalFSM.g:11501:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ;
     public final void rule__SimpleAnnotationAttribute__TypeAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11458:1: ( ( ruleLiteralType ) )
-            // InternalFSM.g:11459:1: ( ruleLiteralType )
+            // InternalFSM.g:11505:1: ( ( ruleLiteralType ) )
+            // InternalFSM.g:11506:1: ( ruleLiteralType )
             {
-            // InternalFSM.g:11459:1: ( ruleLiteralType )
-            // InternalFSM.g:11460:1: ruleLiteralType
+            // InternalFSM.g:11506:1: ( ruleLiteralType )
+            // InternalFSM.g:11507:1: ruleLiteralType
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -30783,21 +30939,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__OptionalAssignment_0_0"
-    // InternalFSM.g:11469:1: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
+    // InternalFSM.g:11516:1: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
     public final void rule__EnumAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11473:1: ( ( ( 'optional' ) ) )
-            // InternalFSM.g:11474:1: ( ( 'optional' ) )
+            // InternalFSM.g:11520:1: ( ( ( 'optional' ) ) )
+            // InternalFSM.g:11521:1: ( ( 'optional' ) )
             {
-            // InternalFSM.g:11474:1: ( ( 'optional' ) )
-            // InternalFSM.g:11475:1: ( 'optional' )
+            // InternalFSM.g:11521:1: ( ( 'optional' ) )
+            // InternalFSM.g:11522:1: ( 'optional' )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalFSM.g:11476:1: ( 'optional' )
-            // InternalFSM.g:11477:1: 'optional'
+            // InternalFSM.g:11523:1: ( 'optional' )
+            // InternalFSM.g:11524:1: 'optional'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,71,FOLLOW_2); 
@@ -30828,17 +30984,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__NameAssignment_2"
-    // InternalFSM.g:11492:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalFSM.g:11539:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__EnumAnnotationAttribute__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11496:1: ( ( RULE_ID ) )
-            // InternalFSM.g:11497:1: ( RULE_ID )
+            // InternalFSM.g:11543:1: ( ( RULE_ID ) )
+            // InternalFSM.g:11544:1: ( RULE_ID )
             {
-            // InternalFSM.g:11497:1: ( RULE_ID )
-            // InternalFSM.g:11498:1: RULE_ID
+            // InternalFSM.g:11544:1: ( RULE_ID )
+            // InternalFSM.g:11545:1: RULE_ID
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -30865,17 +31021,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_5"
-    // InternalFSM.g:11507:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ;
+    // InternalFSM.g:11554:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ;
     public final void rule__EnumAnnotationAttribute__ValuesAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11511:1: ( ( RULE_STRING ) )
-            // InternalFSM.g:11512:1: ( RULE_STRING )
+            // InternalFSM.g:11558:1: ( ( RULE_STRING ) )
+            // InternalFSM.g:11559:1: ( RULE_STRING )
             {
-            // InternalFSM.g:11512:1: ( RULE_STRING )
-            // InternalFSM.g:11513:1: RULE_STRING
+            // InternalFSM.g:11559:1: ( RULE_STRING )
+            // InternalFSM.g:11560:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -30902,17 +31058,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_6_1"
-    // InternalFSM.g:11522:1: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 : ( RULE_STRING ) ;
+    // InternalFSM.g:11569:1: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 : ( RULE_STRING ) ;
     public final void rule__EnumAnnotationAttribute__ValuesAssignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11526:1: ( ( RULE_STRING ) )
-            // InternalFSM.g:11527:1: ( RULE_STRING )
+            // InternalFSM.g:11573:1: ( ( RULE_STRING ) )
+            // InternalFSM.g:11574:1: ( RULE_STRING )
             {
-            // InternalFSM.g:11527:1: ( RULE_STRING )
-            // InternalFSM.g:11528:1: RULE_STRING
+            // InternalFSM.g:11574:1: ( RULE_STRING )
+            // InternalFSM.g:11575:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -30939,17 +31095,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__LinesAssignment_2"
-    // InternalFSM.g:11539:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ;
+    // InternalFSM.g:11586:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ;
     public final void rule__Documentation__LinesAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11543:1: ( ( RULE_STRING ) )
-            // InternalFSM.g:11544:1: ( RULE_STRING )
+            // InternalFSM.g:11590:1: ( ( RULE_STRING ) )
+            // InternalFSM.g:11591:1: ( RULE_STRING )
             {
-            // InternalFSM.g:11544:1: ( RULE_STRING )
-            // InternalFSM.g:11545:1: RULE_STRING
+            // InternalFSM.g:11591:1: ( RULE_STRING )
+            // InternalFSM.g:11592:1: RULE_STRING
             {
              before(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -30976,21 +31132,21 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__IsTrueAssignment_1_1"
-    // InternalFSM.g:11556:1: rule__BooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
+    // InternalFSM.g:11603:1: rule__BooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
     public final void rule__BooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11560:1: ( ( ( 'true' ) ) )
-            // InternalFSM.g:11561:1: ( ( 'true' ) )
+            // InternalFSM.g:11607:1: ( ( ( 'true' ) ) )
+            // InternalFSM.g:11608:1: ( ( 'true' ) )
             {
-            // InternalFSM.g:11561:1: ( ( 'true' ) )
-            // InternalFSM.g:11562:1: ( 'true' )
+            // InternalFSM.g:11608:1: ( ( 'true' ) )
+            // InternalFSM.g:11609:1: ( 'true' )
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
-            // InternalFSM.g:11563:1: ( 'true' )
-            // InternalFSM.g:11564:1: 'true'
+            // InternalFSM.g:11610:1: ( 'true' )
+            // InternalFSM.g:11611:1: 'true'
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
             match(input,72,FOLLOW_2); 
@@ -31021,17 +31177,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__ValueAssignment_1"
-    // InternalFSM.g:11579:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ;
+    // InternalFSM.g:11626:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ;
     public final void rule__RealLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11583:1: ( ( ruleReal ) )
-            // InternalFSM.g:11584:1: ( ruleReal )
+            // InternalFSM.g:11630:1: ( ( ruleReal ) )
+            // InternalFSM.g:11631:1: ( ruleReal )
             {
-            // InternalFSM.g:11584:1: ( ruleReal )
-            // InternalFSM.g:11585:1: ruleReal
+            // InternalFSM.g:11631:1: ( ruleReal )
+            // InternalFSM.g:11632:1: ruleReal
             {
              before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -31062,17 +31218,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__ValueAssignment_1"
-    // InternalFSM.g:11594:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ;
+    // InternalFSM.g:11641:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ;
     public final void rule__IntLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11598:1: ( ( ruleInteger ) )
-            // InternalFSM.g:11599:1: ( ruleInteger )
+            // InternalFSM.g:11645:1: ( ( ruleInteger ) )
+            // InternalFSM.g:11646:1: ( ruleInteger )
             {
-            // InternalFSM.g:11599:1: ( ruleInteger )
-            // InternalFSM.g:11600:1: ruleInteger
+            // InternalFSM.g:11646:1: ( ruleInteger )
+            // InternalFSM.g:11647:1: ruleInteger
             {
              before(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -31103,17 +31259,17 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__ValueAssignment_1"
-    // InternalFSM.g:11609:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
+    // InternalFSM.g:11656:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
     public final void rule__StringLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalFSM.g:11613:1: ( ( RULE_STRING ) )
-            // InternalFSM.g:11614:1: ( RULE_STRING )
+            // InternalFSM.g:11660:1: ( ( RULE_STRING ) )
+            // InternalFSM.g:11661:1: ( RULE_STRING )
             {
-            // InternalFSM.g:11614:1: ( RULE_STRING )
-            // InternalFSM.g:11615:1: RULE_STRING
+            // InternalFSM.g:11661:1: ( RULE_STRING )
+            // InternalFSM.g:11662:1: RULE_STRING
             {
              before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -31141,41 +31297,41 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
     // Delegated rules
 
 
-    protected DFA9 dfa9 = new DFA9(this);
     protected DFA10 dfa10 = new DFA10(this);
+    protected DFA11 dfa11 = new DFA11(this);
     static final String dfa_1s = "\32\uffff";
-    static final String dfa_2s = "\13\uffff\1\21\7\uffff\2\21\1\uffff\1\21\2\uffff\1\21";
-    static final String dfa_3s = "\1\52\1\4\1\53\1\4\1\55\4\4\2\55\1\35\2\4\1\55\1\10\1\36\1\uffff\1\4\2\35\1\10\1\35\2\uffff\1\35";
-    static final String dfa_4s = "\1\52\2\53\1\66\1\65\2\4\1\66\1\4\2\55\1\106\2\4\1\55\1\103\1\62\1\uffff\1\4\2\106\1\103\1\106\2\uffff\1\106";
-    static final String dfa_5s = "\21\uffff\1\2\5\uffff\1\1\1\3\1\uffff";
+    static final String dfa_2s = "\14\uffff\1\22\6\uffff\3\22\1\uffff\1\22\2\uffff";
+    static final String dfa_3s = "\1\52\1\4\1\53\1\4\1\55\4\4\3\55\1\35\3\4\1\10\1\36\1\uffff\3\35\1\10\1\35\2\uffff";
+    static final String dfa_4s = "\1\52\2\53\1\66\1\65\3\4\1\66\3\55\1\106\3\4\1\103\1\62\1\uffff\3\106\1\103\1\106\2\uffff";
+    static final String dfa_5s = "\22\uffff\1\2\5\uffff\1\1\1\3";
     static final String dfa_6s = "\32\uffff}>";
     static final String[] dfa_7s = {
             "\1\1",
             "\1\2\46\uffff\1\3",
             "\1\3",
             "\1\4\57\uffff\1\5\1\uffff\1\6",
-            "\1\7\7\uffff\1\10",
+            "\1\10\7\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\57\uffff\1\14\1\uffff\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
-            "\1\20\1\21\1\uffff\1\21\4\uffff\6\21\10\uffff\1\21\1\uffff\1\22\14\uffff\1\17\3\uffff\1\21",
+            "\1\13",
+            "\1\14\57\uffff\1\15\1\uffff\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
+            "\1\21\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\1\uffff\1\17\14\uffff\1\20\3\uffff\1\22",
             "\1\23",
             "\1\24",
-            "\1\7",
-            "\1\25\72\uffff\1\26",
-            "\1\21\17\uffff\1\21\1\27\1\uffff\1\27\1\30",
+            "\1\25",
+            "\1\26\72\uffff\1\27",
+            "\1\22\17\uffff\1\22\1\30\1\uffff\1\30\1\31",
             "",
-            "\1\31",
-            "\1\20\1\21\1\uffff\1\21\4\uffff\6\21\10\uffff\1\21\16\uffff\1\17\3\uffff\1\21",
-            "\1\20\1\21\1\uffff\1\21\4\uffff\6\21\10\uffff\1\21\16\uffff\1\17\3\uffff\1\21",
-            "\1\25\72\uffff\1\26",
-            "\1\20\1\21\1\uffff\1\21\4\uffff\6\21\10\uffff\1\21\22\uffff\1\21",
+            "\1\21\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\20\3\uffff\1\22",
+            "\1\21\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\20\3\uffff\1\22",
+            "\1\21\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\20\3\uffff\1\22",
+            "\1\26\72\uffff\1\27",
+            "\1\21\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\22\uffff\1\22",
             "",
-            "",
-            "\1\20\1\21\1\uffff\1\21\4\uffff\6\21\10\uffff\1\21\16\uffff\1\17\3\uffff\1\21"
+            ""
     };
 
     static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
@@ -31186,11 +31342,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
     static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
     static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
 
-    class DFA9 extends DFA {
+    class DFA10 extends DFA {
 
-        public DFA9(BaseRecognizer recognizer) {
+        public DFA10(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 9;
+            this.decisionNumber = 10;
             this.eot = dfa_1;
             this.eof = dfa_2;
             this.min = dfa_3;
@@ -31200,32 +31356,32 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_7;
         }
         public String getDescription() {
-            return "1792:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );";
+            return "1839:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );";
         }
     }
     static final String dfa_8s = "\31\uffff";
-    static final String dfa_9s = "\1\52\1\4\1\53\1\4\1\55\4\4\2\55\1\35\2\4\1\55\1\10\1\57\1\4\2\35\1\10\1\35\2\uffff\1\35";
-    static final String dfa_10s = "\1\52\2\53\1\66\1\65\2\4\1\66\1\4\2\55\1\102\2\4\1\55\1\103\1\61\1\4\2\102\1\103\1\35\2\uffff\1\102";
-    static final String dfa_11s = "\26\uffff\1\1\1\2\1\uffff";
+    static final String dfa_9s = "\1\52\1\4\1\53\1\4\1\55\4\4\3\55\1\35\2\4\1\10\1\57\1\4\2\35\1\10\1\35\2\uffff\1\35";
+    static final String dfa_10s = "\1\52\2\53\1\66\1\65\3\4\1\66\3\55\1\102\2\4\1\103\1\61\1\4\2\102\1\103\1\35\2\uffff\1\102";
+    static final String dfa_11s = "\26\uffff\1\2\1\1\1\uffff";
     static final String dfa_12s = "\31\uffff}>";
     static final String[] dfa_13s = {
             "\1\1",
             "\1\2\46\uffff\1\3",
             "\1\3",
             "\1\4\57\uffff\1\5\1\uffff\1\6",
-            "\1\7\7\uffff\1\10",
+            "\1\10\7\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\57\uffff\1\14\1\uffff\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
+            "\1\13",
+            "\1\14\57\uffff\1\15\1\uffff\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
             "\1\20\27\uffff\1\21\14\uffff\1\17",
             "\1\22",
             "\1\23",
-            "\1\7",
             "\1\24\72\uffff\1\25",
-            "\1\26\1\uffff\1\27",
+            "\1\27\1\uffff\1\26",
             "\1\30",
             "\1\20\44\uffff\1\17",
             "\1\20\44\uffff\1\17",
@@ -31243,11 +31399,11 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
     static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
     static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
 
-    class DFA10 extends DFA {
+    class DFA11 extends DFA {
 
-        public DFA10(BaseRecognizer recognizer) {
+        public DFA11(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 10;
+            this.decisionNumber = 11;
             this.eot = dfa_8;
             this.eof = dfa_8;
             this.min = dfa_9;
@@ -31257,7 +31413,7 @@ public class InternalFSMParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_13;
         }
         public String getDescription() {
-            return "1820:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
+            return "1867:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
         }
     }
  
diff --git a/plugins/org.eclipse.etrice.core.fsm.ui/src/org/eclipse/etrice/core/fsm/ui/quickfix/FSMQuickfixProvider.xtend b/plugins/org.eclipse.etrice.core.fsm.ui/src/org/eclipse/etrice/core/fsm/ui/quickfix/FSMQuickfixProvider.xtend
index 498bc4c68..2e4412269 100644
--- a/plugins/org.eclipse.etrice.core.fsm.ui/src/org/eclipse/etrice/core/fsm/ui/quickfix/FSMQuickfixProvider.xtend
+++ b/plugins/org.eclipse.etrice.core.fsm.ui/src/org/eclipse/etrice/core/fsm/ui/quickfix/FSMQuickfixProvider.xtend
@@ -4,12 +4,10 @@
 package org.eclipse.etrice.core.fsm.ui.quickfix
 
 import com.google.inject.Inject
-import org.eclipse.etrice.core.common.converter.BaseConverterService
 import org.eclipse.etrice.core.common.ui.quickfix.BaseQuickfixProvider
 import org.eclipse.etrice.core.fsm.fSM.DetailCode
 import org.eclipse.etrice.core.fsm.validation.FSMJavaValidator
 import org.eclipse.xtext.formatting.IWhitespaceInformationProvider
-import org.eclipse.xtext.nodemodel.util.NodeModelUtils
 import org.eclipse.xtext.ui.editor.quickfix.Fix
 import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionAcceptor
 import org.eclipse.xtext.validation.Issue
@@ -22,9 +20,6 @@ import org.eclipse.xtext.validation.Issue
 class FSMQuickfixProvider extends BaseQuickfixProvider {
 
 	@Inject
-	BaseConverterService converterService
-
-	@Inject
 	IWhitespaceInformationProvider whitespaceProvider;
 
 	@Fix(FSMJavaValidator.PLAIN_STRING_DETAILCODE)
@@ -33,16 +28,9 @@ class FSMQuickfixProvider extends BaseQuickfixProvider {
 			element as DetailCode => [
 				val ccString = lines.join(whitespaceProvider.getLineSeparatorInformation(eResource.URI).lineSeparator)
 				
-				// xtext bug: serializer freezes in many situations (manual serialization via ISerializer does not work either)
-				// semantic change can trigger formatting, activate in RoomUiModule (https://www.eclipse.org/forums/index.php/t/1067512/)
-//				used = false
-//				lines.clear
-//				lines += ccString
-			
-				// workaround, TODO do formatting manually
-				NodeModelUtils.findActualNodeFor(it) => [
-					context.xtextDocument.replace(offset, length, converterService.CC_StringConverter.addDelim(ccString))
-				]
+				used = false
+				lines.clear
+				lines += ccString
 			]			
 		])
 	}
diff --git a/plugins/org.eclipse.etrice.core.fsm/.antlr-generator-3.2.0-patch.jar b/plugins/org.eclipse.etrice.core.fsm/.antlr-generator-3.2.0-patch.jar
deleted file mode 100644
index 90516fd7a..000000000
--- a/plugins/org.eclipse.etrice.core.fsm/.antlr-generator-3.2.0-patch.jar
+++ /dev/null
diff --git a/plugins/org.eclipse.etrice.core.fsm/model/generated/FSM.ecore b/plugins/org.eclipse.etrice.core.fsm/model/generated/FSM.ecore
index 40ece40ca..419bacbe0 100644
--- a/plugins/org.eclipse.etrice.core.fsm/model/generated/FSM.ecore
+++ b/plugins/org.eclipse.etrice.core.fsm/model/generated/FSM.ecore
@@ -30,7 +30,7 @@
     </eAnnotations>
     <eOperations name="getName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="body" value="if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.State%>) &#xD;&#xA;&#x9;return ((State)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.TrPoint%>)&#xD;&#xA;&#x9;return ((TrPoint)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>)&#xD;&#xA;&#x9;return ((ChoicePoint)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.Transition%>)&#xD;&#xA;&#x9;return ((Transition)this).getName();&#xD;&#xA;return &quot;&quot;;&#xD;&#xA;"/>
+        <details key="body" value="if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.State%>) &#xD;&#xA;&#x9;return ((State)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.TrPoint%>)&#xD;&#xA;&#x9;return ((TrPoint)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>)&#xD;&#xA;&#x9;return ((ChoicePoint)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.Transition%>)&#xD;&#xA;&#x9;return ((Transition)this).getName();&#xD;&#xA;else if (this instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>)&#xD;&#xA;&#x9;return ((RefinedTransition)this).getTarget().getName();&#xD;&#xA;return &quot;&quot;;&#xD;&#xA;"/>
       </eAnnotations>
     </eOperations>
   </eClassifiers>
@@ -187,7 +187,7 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="TransitionBase">
+  <eClassifiers xsi:type="ecore:EClass" name="TransitionBase" eSuperTypes="#//StateGraphItem">
     <eStructuralFeatures xsi:type="ecore:EReference" name="docu" eType="ecore:EClass platform:/resource/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/Base.ecore#//Documentation"
         containment="true">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
@@ -201,7 +201,7 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Transition" eSuperTypes="#//StateGraphItem #//TransitionBase">
+  <eClassifiers xsi:type="ecore:EClass" name="Transition" eSuperTypes="#//TransitionBase">
     <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
       <details key="documentation" value="&lt;br>The super class of&#xD;&#xA;&lt;ul>&#xD;&#xA;  &lt;li>{@link InitialTransition}&lt;/li>&#xD;&#xA;  &lt;li>{@link NonInitialTransition}&lt;/li>&#xD;&#xA;&lt;/ul>&#xD;&#xA;"/>
     </eAnnotations>
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/FSM.xtextbin b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/FSM.xtextbin
index 18ef277f4..f236b04bf 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/FSM.xtextbin
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/FSM.xtextbin
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/FSMPackage.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/FSMPackage.java
index a64b747d5..e232b17f9 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/FSMPackage.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/FSMPackage.java
@@ -692,7 +692,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION_BASE__DOCU = 0;
+  int TRANSITION_BASE__DOCU = STATE_GRAPH_ITEM_FEATURE_COUNT + 0;
 
   /**
    * The feature id for the '<em><b>Action</b></em>' containment reference.
@@ -701,7 +701,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION_BASE__ACTION = 1;
+  int TRANSITION_BASE__ACTION = STATE_GRAPH_ITEM_FEATURE_COUNT + 1;
 
   /**
    * The number of structural features of the '<em>Transition Base</em>' class.
@@ -710,7 +710,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION_BASE_FEATURE_COUNT = 2;
+  int TRANSITION_BASE_FEATURE_COUNT = STATE_GRAPH_ITEM_FEATURE_COUNT + 2;
 
   /**
    * The meta object id for the '{@link org.eclipse.etrice.core.fsm.fSM.impl.TransitionImpl <em>Transition</em>}' class.
@@ -729,7 +729,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION__DOCU = STATE_GRAPH_ITEM_FEATURE_COUNT + 0;
+  int TRANSITION__DOCU = TRANSITION_BASE__DOCU;
 
   /**
    * The feature id for the '<em><b>Action</b></em>' containment reference.
@@ -738,7 +738,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION__ACTION = STATE_GRAPH_ITEM_FEATURE_COUNT + 1;
+  int TRANSITION__ACTION = TRANSITION_BASE__ACTION;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -747,7 +747,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION__NAME = STATE_GRAPH_ITEM_FEATURE_COUNT + 2;
+  int TRANSITION__NAME = TRANSITION_BASE_FEATURE_COUNT + 0;
 
   /**
    * The feature id for the '<em><b>To</b></em>' containment reference.
@@ -756,7 +756,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION__TO = STATE_GRAPH_ITEM_FEATURE_COUNT + 3;
+  int TRANSITION__TO = TRANSITION_BASE_FEATURE_COUNT + 1;
 
   /**
    * The number of structural features of the '<em>Transition</em>' class.
@@ -765,7 +765,7 @@ public interface FSMPackage extends EPackage
    * @generated
    * @ordered
    */
-  int TRANSITION_FEATURE_COUNT = STATE_GRAPH_ITEM_FEATURE_COUNT + 4;
+  int TRANSITION_FEATURE_COUNT = TRANSITION_BASE_FEATURE_COUNT + 2;
 
   /**
    * The meta object id for the '{@link org.eclipse.etrice.core.fsm.fSM.impl.NonInitialTransitionImpl <em>Non Initial Transition</em>}' class.
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/StateGraphItem.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/StateGraphItem.java
index 5612c0223..97fae04f3 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/StateGraphItem.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/StateGraphItem.java
@@ -29,7 +29,7 @@ public interface StateGraphItem extends EObject
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.State%>) \r\n\treturn ((State)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.TrPoint%>)\r\n\treturn ((TrPoint)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>)\r\n\treturn ((ChoicePoint)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.Transition%>)\r\n\treturn ((Transition)this).getName();\r\nreturn \"\";\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.State%>) \r\n\treturn ((State)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.TrPoint%>)\r\n\treturn ((TrPoint)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>)\r\n\treturn ((ChoicePoint)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.Transition%>)\r\n\treturn ((Transition)this).getName();\r\nelse if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>)\r\n\treturn ((RefinedTransition)this).getTarget().getName();\r\nreturn \"\";\r\n'"
    * @generated
    */
   String getName();
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/Transition.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/Transition.java
index 762d8c646..0263051ee 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/Transition.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/Transition.java
@@ -29,7 +29,7 @@ package org.eclipse.etrice.core.fsm.fSM;
  * @model
  * @generated
  */
-public interface Transition extends StateGraphItem, TransitionBase
+public interface Transition extends TransitionBase
 {
   /**
    * Returns the value of the '<em><b>Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/TransitionBase.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/TransitionBase.java
index 3b19d4f10..75932b8b4 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/TransitionBase.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/TransitionBase.java
@@ -2,8 +2,6 @@
  */
 package org.eclipse.etrice.core.fsm.fSM;
 
-import org.eclipse.emf.ecore.EObject;
-
 import org.eclipse.etrice.core.common.base.Documentation;
 
 /**
@@ -23,7 +21,7 @@ import org.eclipse.etrice.core.common.base.Documentation;
  * @model
  * @generated
  */
-public interface TransitionBase extends EObject
+public interface TransitionBase extends StateGraphItem
 {
   /**
    * Returns the value of the '<em><b>Docu</b></em>' containment reference.
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/FSMPackageImpl.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/FSMPackageImpl.java
index b3fa0a8d0..af70a9348 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/FSMPackageImpl.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/FSMPackageImpl.java
@@ -1460,7 +1460,7 @@ public class FSMPackageImpl extends EPackageImpl implements FSMPackage
     entryPointEClass.getESuperTypes().add(this.getTrPoint());
     exitPointEClass.getESuperTypes().add(this.getTrPoint());
     choicePointEClass.getESuperTypes().add(this.getStateGraphNode());
-    transitionEClass.getESuperTypes().add(this.getStateGraphItem());
+    transitionBaseEClass.getESuperTypes().add(this.getStateGraphItem());
     transitionEClass.getESuperTypes().add(this.getTransitionBase());
     nonInitialTransitionEClass.getESuperTypes().add(this.getTransition());
     transitionChainStartTransitionEClass.getESuperTypes().add(this.getNonInitialTransition());
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/StateGraphItemImpl.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/StateGraphItemImpl.java
index 6d1b58b3d..d342afa38 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/StateGraphItemImpl.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/StateGraphItemImpl.java
@@ -8,6 +8,7 @@ import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
 
 import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
 import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
 import org.eclipse.etrice.core.fsm.fSM.TrPoint;
@@ -58,6 +59,8 @@ public class StateGraphItemImpl extends MinimalEObjectImpl.Container implements
       return ((ChoicePoint)this).getName();
     else if (this instanceof Transition)
       return ((Transition)this).getName();
+    else if (this instanceof RefinedTransition)
+      return ((RefinedTransition)this).getTarget().getName();
     return "";
     
   }
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionBaseImpl.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionBaseImpl.java
index 3b4ea9f23..66ab6b125 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionBaseImpl.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionBaseImpl.java
@@ -9,7 +9,6 @@ import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
 
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
 
 import org.eclipse.etrice.core.common.base.Documentation;
 
@@ -31,7 +30,7 @@ import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
  *
  * @generated
  */
-public class TransitionBaseImpl extends MinimalEObjectImpl.Container implements TransitionBase
+public class TransitionBaseImpl extends StateGraphItemImpl implements TransitionBase
 {
   /**
    * The cached value of the '{@link #getDocu() <em>Docu</em>}' containment reference.
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionImpl.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionImpl.java
index 0e419c23f..7a92f6d3d 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionImpl.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/impl/TransitionImpl.java
@@ -10,12 +10,8 @@ import org.eclipse.emf.ecore.InternalEObject;
 
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 
-import org.eclipse.etrice.core.common.base.Documentation;
-
-import org.eclipse.etrice.core.fsm.fSM.DetailCode;
 import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
 import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
 
 /**
@@ -26,37 +22,15 @@ import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.etrice.core.fsm.fSM.impl.TransitionImpl#getDocu <em>Docu</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.fsm.fSM.impl.TransitionImpl#getAction <em>Action</em>}</li>
  *   <li>{@link org.eclipse.etrice.core.fsm.fSM.impl.TransitionImpl#getName <em>Name</em>}</li>
  *   <li>{@link org.eclipse.etrice.core.fsm.fSM.impl.TransitionImpl#getTo <em>To</em>}</li>
  * </ul>
  *
  * @generated
  */
-public class TransitionImpl extends StateGraphItemImpl implements Transition
+public class TransitionImpl extends TransitionBaseImpl implements Transition
 {
   /**
-   * The cached value of the '{@link #getDocu() <em>Docu</em>}' containment reference.
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @see #getDocu()
-   * @generated
-   * @ordered
-   */
-  protected Documentation docu;
-
-  /**
-   * The cached value of the '{@link #getAction() <em>Action</em>}' containment reference.
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @see #getAction()
-   * @generated
-   * @ordered
-   */
-  protected DetailCode action;
-
-  /**
    * The default value of the '{@link #getName() <em>Name</em>}' attribute.
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
@@ -112,102 +86,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
    * <!-- end-user-doc -->
    * @generated
    */
-  public Documentation getDocu()
-  {
-    return docu;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public NotificationChain basicSetDocu(Documentation newDocu, NotificationChain msgs)
-  {
-    Documentation oldDocu = docu;
-    docu = newDocu;
-    if (eNotificationRequired())
-    {
-      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FSMPackage.TRANSITION__DOCU, oldDocu, newDocu);
-      if (msgs == null) msgs = notification; else msgs.add(notification);
-    }
-    return msgs;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public void setDocu(Documentation newDocu)
-  {
-    if (newDocu != docu)
-    {
-      NotificationChain msgs = null;
-      if (docu != null)
-        msgs = ((InternalEObject)docu).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FSMPackage.TRANSITION__DOCU, null, msgs);
-      if (newDocu != null)
-        msgs = ((InternalEObject)newDocu).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FSMPackage.TRANSITION__DOCU, null, msgs);
-      msgs = basicSetDocu(newDocu, msgs);
-      if (msgs != null) msgs.dispatch();
-    }
-    else if (eNotificationRequired())
-      eNotify(new ENotificationImpl(this, Notification.SET, FSMPackage.TRANSITION__DOCU, newDocu, newDocu));
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public DetailCode getAction()
-  {
-    return action;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public NotificationChain basicSetAction(DetailCode newAction, NotificationChain msgs)
-  {
-    DetailCode oldAction = action;
-    action = newAction;
-    if (eNotificationRequired())
-    {
-      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FSMPackage.TRANSITION__ACTION, oldAction, newAction);
-      if (msgs == null) msgs = notification; else msgs.add(notification);
-    }
-    return msgs;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public void setAction(DetailCode newAction)
-  {
-    if (newAction != action)
-    {
-      NotificationChain msgs = null;
-      if (action != null)
-        msgs = ((InternalEObject)action).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FSMPackage.TRANSITION__ACTION, null, msgs);
-      if (newAction != null)
-        msgs = ((InternalEObject)newAction).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FSMPackage.TRANSITION__ACTION, null, msgs);
-      msgs = basicSetAction(newAction, msgs);
-      if (msgs != null) msgs.dispatch();
-    }
-    else if (eNotificationRequired())
-      eNotify(new ENotificationImpl(this, Notification.SET, FSMPackage.TRANSITION__ACTION, newAction, newAction));
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
   public String getName()
   {
     return name;
@@ -284,10 +162,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
   {
     switch (featureID)
     {
-      case FSMPackage.TRANSITION__DOCU:
-        return basicSetDocu(null, msgs);
-      case FSMPackage.TRANSITION__ACTION:
-        return basicSetAction(null, msgs);
       case FSMPackage.TRANSITION__TO:
         return basicSetTo(null, msgs);
     }
@@ -304,10 +178,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
   {
     switch (featureID)
     {
-      case FSMPackage.TRANSITION__DOCU:
-        return getDocu();
-      case FSMPackage.TRANSITION__ACTION:
-        return getAction();
       case FSMPackage.TRANSITION__NAME:
         return getName();
       case FSMPackage.TRANSITION__TO:
@@ -326,12 +196,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
   {
     switch (featureID)
     {
-      case FSMPackage.TRANSITION__DOCU:
-        setDocu((Documentation)newValue);
-        return;
-      case FSMPackage.TRANSITION__ACTION:
-        setAction((DetailCode)newValue);
-        return;
       case FSMPackage.TRANSITION__NAME:
         setName((String)newValue);
         return;
@@ -352,12 +216,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
   {
     switch (featureID)
     {
-      case FSMPackage.TRANSITION__DOCU:
-        setDocu((Documentation)null);
-        return;
-      case FSMPackage.TRANSITION__ACTION:
-        setAction((DetailCode)null);
-        return;
       case FSMPackage.TRANSITION__NAME:
         setName(NAME_EDEFAULT);
         return;
@@ -378,10 +236,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
   {
     switch (featureID)
     {
-      case FSMPackage.TRANSITION__DOCU:
-        return docu != null;
-      case FSMPackage.TRANSITION__ACTION:
-        return action != null;
       case FSMPackage.TRANSITION__NAME:
         return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
       case FSMPackage.TRANSITION__TO:
@@ -396,46 +250,6 @@ public class TransitionImpl extends StateGraphItemImpl implements Transition
    * @generated
    */
   @Override
-  public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass)
-  {
-    if (baseClass == TransitionBase.class)
-    {
-      switch (derivedFeatureID)
-      {
-        case FSMPackage.TRANSITION__DOCU: return FSMPackage.TRANSITION_BASE__DOCU;
-        case FSMPackage.TRANSITION__ACTION: return FSMPackage.TRANSITION_BASE__ACTION;
-        default: return -1;
-      }
-    }
-    return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  @Override
-  public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass)
-  {
-    if (baseClass == TransitionBase.class)
-    {
-      switch (baseFeatureID)
-      {
-        case FSMPackage.TRANSITION_BASE__DOCU: return FSMPackage.TRANSITION__DOCU;
-        case FSMPackage.TRANSITION_BASE__ACTION: return FSMPackage.TRANSITION__ACTION;
-        default: return -1;
-      }
-    }
-    return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  @Override
   public String toString()
   {
     if (eIsProxy()) return super.toString();
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/util/FSMSwitch.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/util/FSMSwitch.java
index 6240d332c..eded4f064 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/util/FSMSwitch.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/fSM/util/FSMSwitch.java
@@ -197,6 +197,7 @@ public class FSMSwitch<T> extends Switch<T>
       {
         TransitionBase transitionBase = (TransitionBase)theEObject;
         T result = caseTransitionBase(transitionBase);
+        if (result == null) result = caseStateGraphItem(transitionBase);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -204,8 +205,8 @@ public class FSMSwitch<T> extends Switch<T>
       {
         Transition transition = (Transition)theEObject;
         T result = caseTransition(transition);
-        if (result == null) result = caseStateGraphItem(transition);
         if (result == null) result = caseTransitionBase(transition);
+        if (result == null) result = caseStateGraphItem(transition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -214,8 +215,8 @@ public class FSMSwitch<T> extends Switch<T>
         NonInitialTransition nonInitialTransition = (NonInitialTransition)theEObject;
         T result = caseNonInitialTransition(nonInitialTransition);
         if (result == null) result = caseTransition(nonInitialTransition);
-        if (result == null) result = caseStateGraphItem(nonInitialTransition);
         if (result == null) result = caseTransitionBase(nonInitialTransition);
+        if (result == null) result = caseStateGraphItem(nonInitialTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -225,8 +226,8 @@ public class FSMSwitch<T> extends Switch<T>
         T result = caseTransitionChainStartTransition(transitionChainStartTransition);
         if (result == null) result = caseNonInitialTransition(transitionChainStartTransition);
         if (result == null) result = caseTransition(transitionChainStartTransition);
-        if (result == null) result = caseStateGraphItem(transitionChainStartTransition);
         if (result == null) result = caseTransitionBase(transitionChainStartTransition);
+        if (result == null) result = caseStateGraphItem(transitionChainStartTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -235,8 +236,8 @@ public class FSMSwitch<T> extends Switch<T>
         InitialTransition initialTransition = (InitialTransition)theEObject;
         T result = caseInitialTransition(initialTransition);
         if (result == null) result = caseTransition(initialTransition);
-        if (result == null) result = caseStateGraphItem(initialTransition);
         if (result == null) result = caseTransitionBase(initialTransition);
+        if (result == null) result = caseStateGraphItem(initialTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -246,8 +247,8 @@ public class FSMSwitch<T> extends Switch<T>
         T result = caseContinuationTransition(continuationTransition);
         if (result == null) result = caseNonInitialTransition(continuationTransition);
         if (result == null) result = caseTransition(continuationTransition);
-        if (result == null) result = caseStateGraphItem(continuationTransition);
         if (result == null) result = caseTransitionBase(continuationTransition);
+        if (result == null) result = caseStateGraphItem(continuationTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -258,8 +259,8 @@ public class FSMSwitch<T> extends Switch<T>
         if (result == null) result = caseTransitionChainStartTransition(triggeredTransition);
         if (result == null) result = caseNonInitialTransition(triggeredTransition);
         if (result == null) result = caseTransition(triggeredTransition);
-        if (result == null) result = caseStateGraphItem(triggeredTransition);
         if (result == null) result = caseTransitionBase(triggeredTransition);
+        if (result == null) result = caseStateGraphItem(triggeredTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -270,8 +271,8 @@ public class FSMSwitch<T> extends Switch<T>
         if (result == null) result = caseTransitionChainStartTransition(guardedTransition);
         if (result == null) result = caseNonInitialTransition(guardedTransition);
         if (result == null) result = caseTransition(guardedTransition);
-        if (result == null) result = caseStateGraphItem(guardedTransition);
         if (result == null) result = caseTransitionBase(guardedTransition);
+        if (result == null) result = caseStateGraphItem(guardedTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -281,8 +282,8 @@ public class FSMSwitch<T> extends Switch<T>
         T result = caseCPBranchTransition(cpBranchTransition);
         if (result == null) result = caseNonInitialTransition(cpBranchTransition);
         if (result == null) result = caseTransition(cpBranchTransition);
-        if (result == null) result = caseStateGraphItem(cpBranchTransition);
         if (result == null) result = caseTransitionBase(cpBranchTransition);
+        if (result == null) result = caseStateGraphItem(cpBranchTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
@@ -291,6 +292,7 @@ public class FSMSwitch<T> extends Switch<T>
         RefinedTransition refinedTransition = (RefinedTransition)theEObject;
         T result = caseRefinedTransition(refinedTransition);
         if (result == null) result = caseTransitionBase(refinedTransition);
+        if (result == null) result = caseStateGraphItem(refinedTransition);
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSM.g b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSM.g
index 306b0c24a..3aebaa6b7 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSM.g
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSM.g
@@ -1259,6 +1259,44 @@ ruleChoicePoint returns [EObject current=null]
 
 
 
+// Entry rule entryRuleTransitionBase
+entryRuleTransitionBase returns [EObject current=null] 
+	:
+	{ newCompositeNode(grammarAccess.getTransitionBaseRule()); }
+	 iv_ruleTransitionBase=ruleTransitionBase 
+	 { $current=$iv_ruleTransitionBase.current; } 
+	 EOF 
+;
+
+// Rule TransitionBase
+ruleTransitionBase returns [EObject current=null] 
+    @init { enterRule(); 
+    }
+    @after { leaveRule(); }:
+(
+    { 
+        newCompositeNode(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+    }
+    this_Transition_0=ruleTransition
+    { 
+        $current = $this_Transition_0.current; 
+        afterParserOrEnumRuleCall();
+    }
+
+    |
+    { 
+        newCompositeNode(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+    }
+    this_RefinedTransition_1=ruleRefinedTransition
+    { 
+        $current = $this_RefinedTransition_1.current; 
+        afterParserOrEnumRuleCall();
+    }
+)
+;
+
+
+
 
 
 // Entry rule entryRuleTransition
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMLexer.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMLexer.java
index 859d30fef..c2badead9 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMLexer.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMLexer.java
@@ -1344,10 +1344,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_HEX;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3970:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
-            // InternalFSM.g:3970:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalFSM.g:4008:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalFSM.g:4008:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalFSM.g:3970:12: ( '0x' | '0X' )
+            // InternalFSM.g:4008:12: ( '0x' | '0X' )
             int alt1=2;
             int LA1_0 = input.LA(1);
 
@@ -1375,7 +1375,7 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt1) {
                 case 1 :
-                    // InternalFSM.g:3970:13: '0x'
+                    // InternalFSM.g:4008:13: '0x'
                     {
                     match("0x"); 
 
@@ -1383,7 +1383,7 @@ public class InternalFSMLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3970:18: '0X'
+                    // InternalFSM.g:4008:18: '0X'
                     {
                     match("0X"); 
 
@@ -1393,7 +1393,7 @@ public class InternalFSMLexer extends Lexer {
 
             }
 
-            // InternalFSM.g:3970:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalFSM.g:4008:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             int cnt2=0;
             loop2:
             do {
@@ -1447,12 +1447,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_CC_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3972:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
-            // InternalFSM.g:3972:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+            // InternalFSM.g:4010:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalFSM.g:4010:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalFSM.g:3972:27: ( options {greedy=false; } : . )*
+            // InternalFSM.g:4010:27: ( options {greedy=false; } : . )*
             loop3:
             do {
                 int alt3=2;
@@ -1486,7 +1486,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt3) {
             	case 1 :
-            	    // InternalFSM.g:3972:55: .
+            	    // InternalFSM.g:4010:55: .
             	    {
             	    matchAny(); 
 
@@ -1516,10 +1516,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ID;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3974:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
-            // InternalFSM.g:3974:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalFSM.g:4012:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalFSM.g:4012:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalFSM.g:3974:11: ( '^' )?
+            // InternalFSM.g:4012:11: ( '^' )?
             int alt4=2;
             int LA4_0 = input.LA(1);
 
@@ -1528,7 +1528,7 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt4) {
                 case 1 :
-                    // InternalFSM.g:3974:11: '^'
+                    // InternalFSM.g:4012:11: '^'
                     {
                     match('^'); 
 
@@ -1546,7 +1546,7 @@ public class InternalFSMLexer extends Lexer {
                 recover(mse);
                 throw mse;}
 
-            // InternalFSM.g:3974:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalFSM.g:4012:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             loop5:
             do {
                 int alt5=2;
@@ -1595,10 +1595,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_INT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3976:10: ( ( '0' .. '9' )+ )
-            // InternalFSM.g:3976:12: ( '0' .. '9' )+
+            // InternalFSM.g:4014:10: ( ( '0' .. '9' )+ )
+            // InternalFSM.g:4014:12: ( '0' .. '9' )+
             {
-            // InternalFSM.g:3976:12: ( '0' .. '9' )+
+            // InternalFSM.g:4014:12: ( '0' .. '9' )+
             int cnt6=0;
             loop6:
             do {
@@ -1612,7 +1612,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt6) {
             	case 1 :
-            	    // InternalFSM.g:3976:13: '0' .. '9'
+            	    // InternalFSM.g:4014:13: '0' .. '9'
             	    {
             	    matchRange('0','9'); 
 
@@ -1644,10 +1644,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3978:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
-            // InternalFSM.g:3978:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalFSM.g:4016:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalFSM.g:4016:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalFSM.g:3978:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalFSM.g:4016:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -1665,10 +1665,10 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalFSM.g:3978:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+                    // InternalFSM.g:4016:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalFSM.g:3978:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalFSM.g:4016:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
                     loop7:
                     do {
                         int alt7=3;
@@ -1684,7 +1684,7 @@ public class InternalFSMLexer extends Lexer {
 
                         switch (alt7) {
                     	case 1 :
-                    	    // InternalFSM.g:3978:21: '\\\\' .
+                    	    // InternalFSM.g:4016:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -1692,7 +1692,7 @@ public class InternalFSMLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalFSM.g:3978:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalFSM.g:4016:28: ~ ( ( '\\\\' | '\"' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -1717,10 +1717,10 @@ public class InternalFSMLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3978:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
+                    // InternalFSM.g:4016:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalFSM.g:3978:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalFSM.g:4016:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
                     loop8:
                     do {
                         int alt8=3;
@@ -1736,7 +1736,7 @@ public class InternalFSMLexer extends Lexer {
 
                         switch (alt8) {
                     	case 1 :
-                    	    // InternalFSM.g:3978:54: '\\\\' .
+                    	    // InternalFSM.g:4016:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -1744,7 +1744,7 @@ public class InternalFSMLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalFSM.g:3978:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalFSM.g:4016:61: ~ ( ( '\\\\' | '\\'' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -1787,12 +1787,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ML_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3980:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
-            // InternalFSM.g:3980:19: '/*' ( options {greedy=false; } : . )* '*/'
+            // InternalFSM.g:4018:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalFSM.g:4018:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalFSM.g:3980:24: ( options {greedy=false; } : . )*
+            // InternalFSM.g:4018:24: ( options {greedy=false; } : . )*
             loop10:
             do {
                 int alt10=2;
@@ -1817,7 +1817,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt10) {
             	case 1 :
-            	    // InternalFSM.g:3980:52: .
+            	    // InternalFSM.g:4018:52: .
             	    {
             	    matchAny(); 
 
@@ -1847,12 +1847,12 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_SL_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3982:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
-            // InternalFSM.g:3982:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            // InternalFSM.g:4020:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalFSM.g:4020:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalFSM.g:3982:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalFSM.g:4020:24: (~ ( ( '\\n' | '\\r' ) ) )*
             loop11:
             do {
                 int alt11=2;
@@ -1865,7 +1865,7 @@ public class InternalFSMLexer extends Lexer {
 
                 switch (alt11) {
             	case 1 :
-            	    // InternalFSM.g:3982:24: ~ ( ( '\\n' | '\\r' ) )
+            	    // InternalFSM.g:4020:24: ~ ( ( '\\n' | '\\r' ) )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -1885,7 +1885,7 @@ public class InternalFSMLexer extends Lexer {
                 }
             } while (true);
 
-            // InternalFSM.g:3982:40: ( ( '\\r' )? '\\n' )?
+            // InternalFSM.g:4020:40: ( ( '\\r' )? '\\n' )?
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -1894,9 +1894,9 @@ public class InternalFSMLexer extends Lexer {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalFSM.g:3982:41: ( '\\r' )? '\\n'
+                    // InternalFSM.g:4020:41: ( '\\r' )? '\\n'
                     {
-                    // InternalFSM.g:3982:41: ( '\\r' )?
+                    // InternalFSM.g:4020:41: ( '\\r' )?
                     int alt12=2;
                     int LA12_0 = input.LA(1);
 
@@ -1905,7 +1905,7 @@ public class InternalFSMLexer extends Lexer {
                     }
                     switch (alt12) {
                         case 1 :
-                            // InternalFSM.g:3982:41: '\\r'
+                            // InternalFSM.g:4020:41: '\\r'
                             {
                             match('\r'); 
 
@@ -1937,10 +1937,10 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_WS;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3984:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
-            // InternalFSM.g:3984:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalFSM.g:4022:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalFSM.g:4022:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalFSM.g:3984:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalFSM.g:4022:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             int cnt14=0;
             loop14:
             do {
@@ -1994,8 +1994,8 @@ public class InternalFSMLexer extends Lexer {
         try {
             int _type = RULE_ANY_OTHER;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalFSM.g:3986:16: ( . )
-            // InternalFSM.g:3986:18: .
+            // InternalFSM.g:4024:16: ( . )
+            // InternalFSM.g:4024:18: .
             {
             matchAny(); 
 
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMParser.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMParser.java
index 1ab52f972..8bdf0d692 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMParser.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/parser/antlr/internal/InternalFSMParser.java
@@ -3206,8 +3206,133 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalFSM.g:1263:1: entryRuleTransitionBase returns [EObject current=null] : iv_ruleTransitionBase= ruleTransitionBase EOF ;
+    public final EObject entryRuleTransitionBase() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleTransitionBase = null;
+
+
+        try {
+            // InternalFSM.g:1264:2: (iv_ruleTransitionBase= ruleTransitionBase EOF )
+            // InternalFSM.g:1265:2: iv_ruleTransitionBase= ruleTransitionBase EOF
+            {
+             newCompositeNode(grammarAccess.getTransitionBaseRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleTransitionBase=ruleTransitionBase();
+
+            state._fsp--;
+
+             current =iv_ruleTransitionBase; 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleTransitionBase"
+
+
+    // $ANTLR start "ruleTransitionBase"
+    // InternalFSM.g:1272:1: ruleTransitionBase returns [EObject current=null] : (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition ) ;
+    public final EObject ruleTransitionBase() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_Transition_0 = null;
+
+        EObject this_RefinedTransition_1 = null;
+
+
+         enterRule(); 
+            
+        try {
+            // InternalFSM.g:1275:28: ( (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition ) )
+            // InternalFSM.g:1276:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            {
+            // InternalFSM.g:1276:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            int alt25=2;
+            int LA25_0 = input.LA(1);
+
+            if ( (LA25_0==30) ) {
+                alt25=1;
+            }
+            else if ( (LA25_0==39) ) {
+                alt25=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 25, 0, input);
+
+                throw nvae;
+            }
+            switch (alt25) {
+                case 1 :
+                    // InternalFSM.g:1277:5: this_Transition_0= ruleTransition
+                    {
+                     
+                            newCompositeNode(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+                        
+                    pushFollow(FOLLOW_2);
+                    this_Transition_0=ruleTransition();
+
+                    state._fsp--;
+
+                     
+                            current = this_Transition_0; 
+                            afterParserOrEnumRuleCall();
+                        
+
+                    }
+                    break;
+                case 2 :
+                    // InternalFSM.g:1287:5: this_RefinedTransition_1= ruleRefinedTransition
+                    {
+                     
+                            newCompositeNode(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+                        
+                    pushFollow(FOLLOW_2);
+                    this_RefinedTransition_1=ruleRefinedTransition();
+
+                    state._fsp--;
+
+                     
+                            current = this_RefinedTransition_1; 
+                            afterParserOrEnumRuleCall();
+                        
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+             leaveRule(); 
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleTransitionBase"
+
+
     // $ANTLR start "entryRuleTransition"
-    // InternalFSM.g:1265:1: entryRuleTransition returns [EObject current=null] : iv_ruleTransition= ruleTransition EOF ;
+    // InternalFSM.g:1303:1: entryRuleTransition returns [EObject current=null] : iv_ruleTransition= ruleTransition EOF ;
     public final EObject entryRuleTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3215,8 +3340,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1266:2: (iv_ruleTransition= ruleTransition EOF )
-            // InternalFSM.g:1267:2: iv_ruleTransition= ruleTransition EOF
+            // InternalFSM.g:1304:2: (iv_ruleTransition= ruleTransition EOF )
+            // InternalFSM.g:1305:2: iv_ruleTransition= ruleTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -3243,7 +3368,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransition"
-    // InternalFSM.g:1274:1: ruleTransition returns [EObject current=null] : (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) ;
+    // InternalFSM.g:1312:1: ruleTransition returns [EObject current=null] : (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) ;
     public final EObject ruleTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3255,74 +3380,74 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1277:28: ( (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) )
-            // InternalFSM.g:1278:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
+            // InternalFSM.g:1315:28: ( (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) )
+            // InternalFSM.g:1316:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
             {
-            // InternalFSM.g:1278:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
-            int alt25=2;
-            int LA25_0 = input.LA(1);
+            // InternalFSM.g:1316:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
+            int alt26=2;
+            int LA26_0 = input.LA(1);
 
-            if ( (LA25_0==30) ) {
-                int LA25_1 = input.LA(2);
+            if ( (LA26_0==30) ) {
+                int LA26_1 = input.LA(2);
 
-                if ( (LA25_1==RULE_ID) ) {
-                    int LA25_2 = input.LA(3);
+                if ( (LA26_1==RULE_ID) ) {
+                    int LA26_2 = input.LA(3);
 
-                    if ( (LA25_2==31) ) {
-                        int LA25_3 = input.LA(4);
+                    if ( (LA26_2==31) ) {
+                        int LA26_3 = input.LA(4);
 
-                        if ( (LA25_3==RULE_ID||LA25_3==40||LA25_3==42) ) {
-                            alt25=2;
+                        if ( (LA26_3==RULE_ID||LA26_3==40||LA26_3==42) ) {
+                            alt26=2;
                         }
-                        else if ( (LA25_3==32) ) {
-                            alt25=1;
+                        else if ( (LA26_3==32) ) {
+                            alt26=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 25, 3, input);
+                                new NoViableAltException("", 26, 3, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 25, 2, input);
+                            new NoViableAltException("", 26, 2, input);
 
                         throw nvae;
                     }
                 }
-                else if ( (LA25_1==31) ) {
-                    int LA25_3 = input.LA(3);
+                else if ( (LA26_1==31) ) {
+                    int LA26_3 = input.LA(3);
 
-                    if ( (LA25_3==RULE_ID||LA25_3==40||LA25_3==42) ) {
-                        alt25=2;
+                    if ( (LA26_3==RULE_ID||LA26_3==40||LA26_3==42) ) {
+                        alt26=2;
                     }
-                    else if ( (LA25_3==32) ) {
-                        alt25=1;
+                    else if ( (LA26_3==32) ) {
+                        alt26=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 25, 3, input);
+                            new NoViableAltException("", 26, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 25, 1, input);
+                        new NoViableAltException("", 26, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 25, 0, input);
+                    new NoViableAltException("", 26, 0, input);
 
                 throw nvae;
             }
-            switch (alt25) {
+            switch (alt26) {
                 case 1 :
-                    // InternalFSM.g:1279:5: this_InitialTransition_0= ruleInitialTransition
+                    // InternalFSM.g:1317:5: this_InitialTransition_0= ruleInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
@@ -3340,7 +3465,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1289:5: this_NonInitialTransition_1= ruleNonInitialTransition
+                    // InternalFSM.g:1327:5: this_NonInitialTransition_1= ruleNonInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
@@ -3378,7 +3503,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalFSM.g:1305:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
+    // InternalFSM.g:1343:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
     public final EObject entryRuleNonInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3386,8 +3511,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1306:2: (iv_ruleNonInitialTransition= ruleNonInitialTransition EOF )
-            // InternalFSM.g:1307:2: iv_ruleNonInitialTransition= ruleNonInitialTransition EOF
+            // InternalFSM.g:1344:2: (iv_ruleNonInitialTransition= ruleNonInitialTransition EOF )
+            // InternalFSM.g:1345:2: iv_ruleNonInitialTransition= ruleNonInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -3414,7 +3539,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleNonInitialTransition"
-    // InternalFSM.g:1314:1: ruleNonInitialTransition returns [EObject current=null] : (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) ;
+    // InternalFSM.g:1352:1: ruleNonInitialTransition returns [EObject current=null] : (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) ;
     public final EObject ruleNonInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3428,15 +3553,15 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1317:28: ( (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) )
-            // InternalFSM.g:1318:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
+            // InternalFSM.g:1355:28: ( (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) )
+            // InternalFSM.g:1356:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
             {
-            // InternalFSM.g:1318:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
-            int alt26=3;
-            alt26 = dfa26.predict(input);
-            switch (alt26) {
+            // InternalFSM.g:1356:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
+            int alt27=3;
+            alt27 = dfa27.predict(input);
+            switch (alt27) {
                 case 1 :
-                    // InternalFSM.g:1319:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
+                    // InternalFSM.g:1357:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
@@ -3454,7 +3579,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1329:5: this_ContinuationTransition_1= ruleContinuationTransition
+                    // InternalFSM.g:1367:5: this_ContinuationTransition_1= ruleContinuationTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
@@ -3472,7 +3597,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:1339:5: this_CPBranchTransition_2= ruleCPBranchTransition
+                    // InternalFSM.g:1377:5: this_CPBranchTransition_2= ruleCPBranchTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
@@ -3510,7 +3635,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalFSM.g:1355:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
+    // InternalFSM.g:1393:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
     public final EObject entryRuleTransitionChainStartTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3518,8 +3643,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1356:2: (iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF )
-            // InternalFSM.g:1357:2: iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF
+            // InternalFSM.g:1394:2: (iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF )
+            // InternalFSM.g:1395:2: iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -3546,7 +3671,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransitionChainStartTransition"
-    // InternalFSM.g:1364:1: ruleTransitionChainStartTransition returns [EObject current=null] : (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) ;
+    // InternalFSM.g:1402:1: ruleTransitionChainStartTransition returns [EObject current=null] : (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) ;
     public final EObject ruleTransitionChainStartTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3558,15 +3683,15 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1367:28: ( (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) )
-            // InternalFSM.g:1368:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
+            // InternalFSM.g:1405:28: ( (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) )
+            // InternalFSM.g:1406:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
             {
-            // InternalFSM.g:1368:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
-            int alt27=2;
-            alt27 = dfa27.predict(input);
-            switch (alt27) {
+            // InternalFSM.g:1406:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
+            int alt28=2;
+            alt28 = dfa28.predict(input);
+            switch (alt28) {
                 case 1 :
-                    // InternalFSM.g:1369:5: this_TriggeredTransition_0= ruleTriggeredTransition
+                    // InternalFSM.g:1407:5: this_TriggeredTransition_0= ruleTriggeredTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
@@ -3584,7 +3709,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:1379:5: this_GuardedTransition_1= ruleGuardedTransition
+                    // InternalFSM.g:1417:5: this_GuardedTransition_1= ruleGuardedTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
@@ -3622,7 +3747,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalFSM.g:1395:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
+    // InternalFSM.g:1433:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
     public final EObject entryRuleInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3630,8 +3755,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1396:2: (iv_ruleInitialTransition= ruleInitialTransition EOF )
-            // InternalFSM.g:1397:2: iv_ruleInitialTransition= ruleInitialTransition EOF
+            // InternalFSM.g:1434:2: (iv_ruleInitialTransition= ruleInitialTransition EOF )
+            // InternalFSM.g:1435:2: iv_ruleInitialTransition= ruleInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -3658,7 +3783,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInitialTransition"
-    // InternalFSM.g:1404:1: ruleInitialTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
+    // InternalFSM.g:1442:1: ruleInitialTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
     public final EObject ruleInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3680,29 +3805,29 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1407:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
-            // InternalFSM.g:1408:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalFSM.g:1445:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
+            // InternalFSM.g:1446:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
             {
-            // InternalFSM.g:1408:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
-            // InternalFSM.g:1408:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            // InternalFSM.g:1446:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalFSM.g:1446:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
             {
             otherlv_0=(Token)match(input,30,FOLLOW_23); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalFSM.g:1412:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt28=2;
-            int LA28_0 = input.LA(1);
+            // InternalFSM.g:1450:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt29=2;
+            int LA29_0 = input.LA(1);
 
-            if ( (LA28_0==RULE_ID) ) {
-                alt28=1;
+            if ( (LA29_0==RULE_ID) ) {
+                alt29=1;
             }
-            switch (alt28) {
+            switch (alt29) {
                 case 1 :
-                    // InternalFSM.g:1413:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1451:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalFSM.g:1413:1: (lv_name_1_0= RULE_ID )
-                    // InternalFSM.g:1414:3: lv_name_1_0= RULE_ID
+                    // InternalFSM.g:1451:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1452:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -3739,11 +3864,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalFSM.g:1442:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1443:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1480:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1481:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1443:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalFSM.g:1444:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalFSM.g:1481:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1482:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -3770,19 +3895,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1460:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt29=2;
-            int LA29_0 = input.LA(1);
+            // InternalFSM.g:1498:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt30=2;
+            int LA30_0 = input.LA(1);
 
-            if ( (LA29_0==56) ) {
-                alt29=1;
+            if ( (LA30_0==56) ) {
+                alt30=1;
             }
-            switch (alt29) {
+            switch (alt30) {
                 case 1 :
-                    // InternalFSM.g:1461:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1499:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:1461:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalFSM.g:1462:3: lv_docu_6_0= ruleDocumentation
+                    // InternalFSM.g:1499:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1500:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -3812,41 +3937,41 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1478:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
-            int alt31=2;
-            int LA31_0 = input.LA(1);
+            // InternalFSM.g:1516:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt32=2;
+            int LA32_0 = input.LA(1);
 
-            if ( (LA31_0==16) ) {
-                alt31=1;
+            if ( (LA32_0==16) ) {
+                alt32=1;
             }
-            switch (alt31) {
+            switch (alt32) {
                 case 1 :
-                    // InternalFSM.g:1478:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalFSM.g:1516:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
                     otherlv_7=(Token)match(input,16,FOLLOW_28); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0());
                         
-                    // InternalFSM.g:1482:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
-                    int alt30=2;
-                    int LA30_0 = input.LA(1);
+                    // InternalFSM.g:1520:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt31=2;
+                    int LA31_0 = input.LA(1);
 
-                    if ( (LA30_0==34) ) {
-                        alt30=1;
+                    if ( (LA31_0==34) ) {
+                        alt31=1;
                     }
-                    switch (alt30) {
+                    switch (alt31) {
                         case 1 :
-                            // InternalFSM.g:1482:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalFSM.g:1520:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
                             otherlv_8=(Token)match(input,34,FOLLOW_29); 
 
                                 	newLeafNode(otherlv_8, grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0());
                                 
-                            // InternalFSM.g:1486:1: ( (lv_action_9_0= ruleDetailCode ) )
-                            // InternalFSM.g:1487:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalFSM.g:1524:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalFSM.g:1525:1: (lv_action_9_0= ruleDetailCode )
                             {
-                            // InternalFSM.g:1487:1: (lv_action_9_0= ruleDetailCode )
-                            // InternalFSM.g:1488:3: lv_action_9_0= ruleDetailCode
+                            // InternalFSM.g:1525:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalFSM.g:1526:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -3910,7 +4035,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalFSM.g:1516:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
+    // InternalFSM.g:1554:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
     public final EObject entryRuleContinuationTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3918,8 +4043,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1517:2: (iv_ruleContinuationTransition= ruleContinuationTransition EOF )
-            // InternalFSM.g:1518:2: iv_ruleContinuationTransition= ruleContinuationTransition EOF
+            // InternalFSM.g:1555:2: (iv_ruleContinuationTransition= ruleContinuationTransition EOF )
+            // InternalFSM.g:1556:2: iv_ruleContinuationTransition= ruleContinuationTransition EOF
             {
              newCompositeNode(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -3946,7 +4071,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleContinuationTransition"
-    // InternalFSM.g:1525:1: ruleContinuationTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
+    // InternalFSM.g:1563:1: ruleContinuationTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
     public final EObject ruleContinuationTransition() throws RecognitionException {
         EObject current = null;
 
@@ -3969,29 +4094,29 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1528:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
-            // InternalFSM.g:1529:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalFSM.g:1566:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
+            // InternalFSM.g:1567:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
             {
-            // InternalFSM.g:1529:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
-            // InternalFSM.g:1529:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            // InternalFSM.g:1567:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalFSM.g:1567:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
             {
             otherlv_0=(Token)match(input,30,FOLLOW_23); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalFSM.g:1533:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt32=2;
-            int LA32_0 = input.LA(1);
+            // InternalFSM.g:1571:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt33=2;
+            int LA33_0 = input.LA(1);
 
-            if ( (LA32_0==RULE_ID) ) {
-                alt32=1;
+            if ( (LA33_0==RULE_ID) ) {
+                alt33=1;
             }
-            switch (alt32) {
+            switch (alt33) {
                 case 1 :
-                    // InternalFSM.g:1534:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1572:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalFSM.g:1534:1: (lv_name_1_0= RULE_ID )
-                    // InternalFSM.g:1535:3: lv_name_1_0= RULE_ID
+                    // InternalFSM.g:1572:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1573:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -4020,11 +4145,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getContinuationTransitionAccess().getColonKeyword_2());
                 
-            // InternalFSM.g:1555:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1556:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1593:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1594:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1556:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalFSM.g:1557:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalFSM.g:1594:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1595:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -4055,11 +4180,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalFSM.g:1577:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1578:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1615:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1616:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1578:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalFSM.g:1579:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalFSM.g:1616:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1617:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -4086,19 +4211,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1595:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt33=2;
-            int LA33_0 = input.LA(1);
+            // InternalFSM.g:1633:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt34=2;
+            int LA34_0 = input.LA(1);
 
-            if ( (LA33_0==56) ) {
-                alt33=1;
+            if ( (LA34_0==56) ) {
+                alt34=1;
             }
-            switch (alt33) {
+            switch (alt34) {
                 case 1 :
-                    // InternalFSM.g:1596:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1634:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:1596:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalFSM.g:1597:3: lv_docu_6_0= ruleDocumentation
+                    // InternalFSM.g:1634:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1635:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -4128,41 +4253,41 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1613:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
-            int alt35=2;
-            int LA35_0 = input.LA(1);
+            // InternalFSM.g:1651:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt36=2;
+            int LA36_0 = input.LA(1);
 
-            if ( (LA35_0==16) ) {
-                alt35=1;
+            if ( (LA36_0==16) ) {
+                alt36=1;
             }
-            switch (alt35) {
+            switch (alt36) {
                 case 1 :
-                    // InternalFSM.g:1613:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalFSM.g:1651:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
                     otherlv_7=(Token)match(input,16,FOLLOW_28); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0());
                         
-                    // InternalFSM.g:1617:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
-                    int alt34=2;
-                    int LA34_0 = input.LA(1);
+                    // InternalFSM.g:1655:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt35=2;
+                    int LA35_0 = input.LA(1);
 
-                    if ( (LA34_0==34) ) {
-                        alt34=1;
+                    if ( (LA35_0==34) ) {
+                        alt35=1;
                     }
-                    switch (alt34) {
+                    switch (alt35) {
                         case 1 :
-                            // InternalFSM.g:1617:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalFSM.g:1655:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
                             otherlv_8=(Token)match(input,34,FOLLOW_29); 
 
                                 	newLeafNode(otherlv_8, grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0());
                                 
-                            // InternalFSM.g:1621:1: ( (lv_action_9_0= ruleDetailCode ) )
-                            // InternalFSM.g:1622:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalFSM.g:1659:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalFSM.g:1660:1: (lv_action_9_0= ruleDetailCode )
                             {
-                            // InternalFSM.g:1622:1: (lv_action_9_0= ruleDetailCode )
-                            // InternalFSM.g:1623:3: lv_action_9_0= ruleDetailCode
+                            // InternalFSM.g:1660:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalFSM.g:1661:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -4226,7 +4351,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalFSM.g:1651:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
+    // InternalFSM.g:1689:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
     public final EObject entryRuleTriggeredTransition() throws RecognitionException {
         EObject current = null;
 
@@ -4234,8 +4359,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1652:2: (iv_ruleTriggeredTransition= ruleTriggeredTransition EOF )
-            // InternalFSM.g:1653:2: iv_ruleTriggeredTransition= ruleTriggeredTransition EOF
+            // InternalFSM.g:1690:2: (iv_ruleTriggeredTransition= ruleTriggeredTransition EOF )
+            // InternalFSM.g:1691:2: iv_ruleTriggeredTransition= ruleTriggeredTransition EOF
             {
              newCompositeNode(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -4262,7 +4387,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTriggeredTransition"
-    // InternalFSM.g:1660:1: ruleTriggeredTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) ;
+    // InternalFSM.g:1698:1: ruleTriggeredTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) ;
     public final EObject ruleTriggeredTransition() throws RecognitionException {
         EObject current = null;
 
@@ -4293,29 +4418,29 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1663:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) )
-            // InternalFSM.g:1664:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
+            // InternalFSM.g:1701:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) )
+            // InternalFSM.g:1702:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
             {
-            // InternalFSM.g:1664:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
-            // InternalFSM.g:1664:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}'
+            // InternalFSM.g:1702:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
+            // InternalFSM.g:1702:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}'
             {
             otherlv_0=(Token)match(input,30,FOLLOW_23); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalFSM.g:1668:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt36=2;
-            int LA36_0 = input.LA(1);
+            // InternalFSM.g:1706:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt37=2;
+            int LA37_0 = input.LA(1);
 
-            if ( (LA36_0==RULE_ID) ) {
-                alt36=1;
+            if ( (LA37_0==RULE_ID) ) {
+                alt37=1;
             }
-            switch (alt36) {
+            switch (alt37) {
                 case 1 :
-                    // InternalFSM.g:1669:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1707:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalFSM.g:1669:1: (lv_name_1_0= RULE_ID )
-                    // InternalFSM.g:1670:3: lv_name_1_0= RULE_ID
+                    // InternalFSM.g:1707:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1708:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -4344,11 +4469,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2());
                 
-            // InternalFSM.g:1690:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1691:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1728:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1729:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1691:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalFSM.g:1692:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalFSM.g:1729:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1730:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -4379,11 +4504,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalFSM.g:1712:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1713:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1750:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1751:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1713:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalFSM.g:1714:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalFSM.g:1751:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1752:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -4410,19 +4535,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1730:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt37=2;
-            int LA37_0 = input.LA(1);
+            // InternalFSM.g:1768:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt38=2;
+            int LA38_0 = input.LA(1);
 
-            if ( (LA37_0==56) ) {
-                alt37=1;
+            if ( (LA38_0==56) ) {
+                alt38=1;
             }
-            switch (alt37) {
+            switch (alt38) {
                 case 1 :
-                    // InternalFSM.g:1731:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1769:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:1731:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalFSM.g:1732:3: lv_docu_6_0= ruleDocumentation
+                    // InternalFSM.g:1769:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1770:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -4464,11 +4589,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_9, grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9());
                 
-            // InternalFSM.g:1760:1: ( (lv_triggers_10_0= ruleTrigger ) )
-            // InternalFSM.g:1761:1: (lv_triggers_10_0= ruleTrigger )
+            // InternalFSM.g:1798:1: ( (lv_triggers_10_0= ruleTrigger ) )
+            // InternalFSM.g:1799:1: (lv_triggers_10_0= ruleTrigger )
             {
-            // InternalFSM.g:1761:1: (lv_triggers_10_0= ruleTrigger )
-            // InternalFSM.g:1762:3: lv_triggers_10_0= ruleTrigger
+            // InternalFSM.g:1799:1: (lv_triggers_10_0= ruleTrigger )
+            // InternalFSM.g:1800:3: lv_triggers_10_0= ruleTrigger
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
@@ -4495,30 +4620,30 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1778:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
-            loop38:
+            // InternalFSM.g:1816:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
+            loop39:
             do {
-                int alt38=2;
-                int LA38_0 = input.LA(1);
+                int alt39=2;
+                int LA39_0 = input.LA(1);
 
-                if ( (LA38_0==36) ) {
-                    alt38=1;
+                if ( (LA39_0==36) ) {
+                    alt39=1;
                 }
 
 
-                switch (alt38) {
+                switch (alt39) {
             	case 1 :
-            	    // InternalFSM.g:1778:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalFSM.g:1816:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
             	    {
             	    otherlv_11=(Token)match(input,36,FOLLOW_31); 
 
             	        	newLeafNode(otherlv_11, grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0());
             	        
-            	    // InternalFSM.g:1782:1: ( (lv_triggers_12_0= ruleTrigger ) )
-            	    // InternalFSM.g:1783:1: (lv_triggers_12_0= ruleTrigger )
+            	    // InternalFSM.g:1820:1: ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalFSM.g:1821:1: (lv_triggers_12_0= ruleTrigger )
             	    {
-            	    // InternalFSM.g:1783:1: (lv_triggers_12_0= ruleTrigger )
-            	    // InternalFSM.g:1784:3: lv_triggers_12_0= ruleTrigger
+            	    // InternalFSM.g:1821:1: (lv_triggers_12_0= ruleTrigger )
+            	    // InternalFSM.g:1822:3: lv_triggers_12_0= ruleTrigger
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
@@ -4550,7 +4675,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop38;
+            	    break loop39;
                 }
             } while (true);
 
@@ -4558,26 +4683,26 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_13, grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12());
                 
-            // InternalFSM.g:1804:1: (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )?
-            int alt39=2;
-            int LA39_0 = input.LA(1);
+            // InternalFSM.g:1842:1: (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )?
+            int alt40=2;
+            int LA40_0 = input.LA(1);
 
-            if ( (LA39_0==34) ) {
-                alt39=1;
+            if ( (LA40_0==34) ) {
+                alt40=1;
             }
-            switch (alt39) {
+            switch (alt40) {
                 case 1 :
-                    // InternalFSM.g:1804:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalFSM.g:1842:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
                     {
                     otherlv_14=(Token)match(input,34,FOLLOW_29); 
 
                         	newLeafNode(otherlv_14, grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0());
                         
-                    // InternalFSM.g:1808:1: ( (lv_action_15_0= ruleDetailCode ) )
-                    // InternalFSM.g:1809:1: (lv_action_15_0= ruleDetailCode )
+                    // InternalFSM.g:1846:1: ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalFSM.g:1847:1: (lv_action_15_0= ruleDetailCode )
                     {
-                    // InternalFSM.g:1809:1: (lv_action_15_0= ruleDetailCode )
-                    // InternalFSM.g:1810:3: lv_action_15_0= ruleDetailCode
+                    // InternalFSM.g:1847:1: (lv_action_15_0= ruleDetailCode )
+                    // InternalFSM.g:1848:3: lv_action_15_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
@@ -4635,7 +4760,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalFSM.g:1838:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
+    // InternalFSM.g:1876:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
     public final EObject entryRuleGuardedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -4643,8 +4768,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1839:2: (iv_ruleGuardedTransition= ruleGuardedTransition EOF )
-            // InternalFSM.g:1840:2: iv_ruleGuardedTransition= ruleGuardedTransition EOF
+            // InternalFSM.g:1877:2: (iv_ruleGuardedTransition= ruleGuardedTransition EOF )
+            // InternalFSM.g:1878:2: iv_ruleGuardedTransition= ruleGuardedTransition EOF
             {
              newCompositeNode(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -4671,7 +4796,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleGuardedTransition"
-    // InternalFSM.g:1847:1: ruleGuardedTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
+    // InternalFSM.g:1885:1: ruleGuardedTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
     public final EObject ruleGuardedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -4697,29 +4822,29 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:1850:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
-            // InternalFSM.g:1851:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalFSM.g:1888:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
+            // InternalFSM.g:1889:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
             {
-            // InternalFSM.g:1851:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
-            // InternalFSM.g:1851:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
+            // InternalFSM.g:1889:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalFSM.g:1889:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
             {
             otherlv_0=(Token)match(input,30,FOLLOW_23); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalFSM.g:1855:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt40=2;
-            int LA40_0 = input.LA(1);
+            // InternalFSM.g:1893:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt41=2;
+            int LA41_0 = input.LA(1);
 
-            if ( (LA40_0==RULE_ID) ) {
-                alt40=1;
+            if ( (LA41_0==RULE_ID) ) {
+                alt41=1;
             }
-            switch (alt40) {
+            switch (alt41) {
                 case 1 :
-                    // InternalFSM.g:1856:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1894:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalFSM.g:1856:1: (lv_name_1_0= RULE_ID )
-                    // InternalFSM.g:1857:3: lv_name_1_0= RULE_ID
+                    // InternalFSM.g:1894:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:1895:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -4748,11 +4873,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getGuardedTransitionAccess().getColonKeyword_2());
                 
-            // InternalFSM.g:1877:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1878:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1915:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1916:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1878:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalFSM.g:1879:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalFSM.g:1916:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:1917:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -4783,11 +4908,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalFSM.g:1899:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:1900:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1937:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:1938:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:1900:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalFSM.g:1901:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalFSM.g:1938:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:1939:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -4814,19 +4939,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1917:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt41=2;
-            int LA41_0 = input.LA(1);
+            // InternalFSM.g:1955:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt42=2;
+            int LA42_0 = input.LA(1);
 
-            if ( (LA41_0==56) ) {
-                alt41=1;
+            if ( (LA42_0==56) ) {
+                alt42=1;
             }
-            switch (alt41) {
+            switch (alt42) {
                 case 1 :
-                    // InternalFSM.g:1918:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1956:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:1918:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalFSM.g:1919:3: lv_docu_6_0= ruleDocumentation
+                    // InternalFSM.g:1956:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:1957:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -4864,11 +4989,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_8, grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8());
                 
-            // InternalFSM.g:1943:1: ( (lv_guard_9_0= ruleDetailCode ) )
-            // InternalFSM.g:1944:1: (lv_guard_9_0= ruleDetailCode )
+            // InternalFSM.g:1981:1: ( (lv_guard_9_0= ruleDetailCode ) )
+            // InternalFSM.g:1982:1: (lv_guard_9_0= ruleDetailCode )
             {
-            // InternalFSM.g:1944:1: (lv_guard_9_0= ruleDetailCode )
-            // InternalFSM.g:1945:3: lv_guard_9_0= ruleDetailCode
+            // InternalFSM.g:1982:1: (lv_guard_9_0= ruleDetailCode )
+            // InternalFSM.g:1983:3: lv_guard_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
@@ -4895,26 +5020,26 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:1961:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
-            int alt42=2;
-            int LA42_0 = input.LA(1);
+            // InternalFSM.g:1999:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt43=2;
+            int LA43_0 = input.LA(1);
 
-            if ( (LA42_0==34) ) {
-                alt42=1;
+            if ( (LA43_0==34) ) {
+                alt43=1;
             }
-            switch (alt42) {
+            switch (alt43) {
                 case 1 :
-                    // InternalFSM.g:1961:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalFSM.g:1999:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
                     otherlv_10=(Token)match(input,34,FOLLOW_29); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0());
                         
-                    // InternalFSM.g:1965:1: ( (lv_action_11_0= ruleDetailCode ) )
-                    // InternalFSM.g:1966:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalFSM.g:2003:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalFSM.g:2004:1: (lv_action_11_0= ruleDetailCode )
                     {
-                    // InternalFSM.g:1966:1: (lv_action_11_0= ruleDetailCode )
-                    // InternalFSM.g:1967:3: lv_action_11_0= ruleDetailCode
+                    // InternalFSM.g:2004:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalFSM.g:2005:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -4972,7 +5097,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalFSM.g:1995:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
+    // InternalFSM.g:2033:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
     public final EObject entryRuleCPBranchTransition() throws RecognitionException {
         EObject current = null;
 
@@ -4980,8 +5105,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:1996:2: (iv_ruleCPBranchTransition= ruleCPBranchTransition EOF )
-            // InternalFSM.g:1997:2: iv_ruleCPBranchTransition= ruleCPBranchTransition EOF
+            // InternalFSM.g:2034:2: (iv_ruleCPBranchTransition= ruleCPBranchTransition EOF )
+            // InternalFSM.g:2035:2: iv_ruleCPBranchTransition= ruleCPBranchTransition EOF
             {
              newCompositeNode(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5008,7 +5133,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleCPBranchTransition"
-    // InternalFSM.g:2004:1: ruleCPBranchTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
+    // InternalFSM.g:2042:1: ruleCPBranchTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
     public final EObject ruleCPBranchTransition() throws RecognitionException {
         EObject current = null;
 
@@ -5034,29 +5159,29 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2007:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
-            // InternalFSM.g:2008:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalFSM.g:2045:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
+            // InternalFSM.g:2046:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
             {
-            // InternalFSM.g:2008:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
-            // InternalFSM.g:2008:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
+            // InternalFSM.g:2046:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalFSM.g:2046:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
             {
             otherlv_0=(Token)match(input,30,FOLLOW_23); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalFSM.g:2012:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt43=2;
-            int LA43_0 = input.LA(1);
+            // InternalFSM.g:2050:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt44=2;
+            int LA44_0 = input.LA(1);
 
-            if ( (LA43_0==RULE_ID) ) {
-                alt43=1;
+            if ( (LA44_0==RULE_ID) ) {
+                alt44=1;
             }
-            switch (alt43) {
+            switch (alt44) {
                 case 1 :
-                    // InternalFSM.g:2013:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:2051:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalFSM.g:2013:1: (lv_name_1_0= RULE_ID )
-                    // InternalFSM.g:2014:3: lv_name_1_0= RULE_ID
+                    // InternalFSM.g:2051:1: (lv_name_1_0= RULE_ID )
+                    // InternalFSM.g:2052:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -5085,11 +5210,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2());
                 
-            // InternalFSM.g:2034:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:2035:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:2072:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:2073:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:2035:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalFSM.g:2036:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalFSM.g:2073:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalFSM.g:2074:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -5120,11 +5245,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalFSM.g:2056:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalFSM.g:2057:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:2094:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalFSM.g:2095:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalFSM.g:2057:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalFSM.g:2058:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalFSM.g:2095:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalFSM.g:2096:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -5151,19 +5276,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2074:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt44=2;
-            int LA44_0 = input.LA(1);
+            // InternalFSM.g:2112:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt45=2;
+            int LA45_0 = input.LA(1);
 
-            if ( (LA44_0==56) ) {
-                alt44=1;
+            if ( (LA45_0==56) ) {
+                alt45=1;
             }
-            switch (alt44) {
+            switch (alt45) {
                 case 1 :
-                    // InternalFSM.g:2075:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:2113:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:2075:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalFSM.g:2076:3: lv_docu_6_0= ruleDocumentation
+                    // InternalFSM.g:2113:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalFSM.g:2114:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -5201,11 +5326,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_8, grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8());
                 
-            // InternalFSM.g:2100:1: ( (lv_condition_9_0= ruleDetailCode ) )
-            // InternalFSM.g:2101:1: (lv_condition_9_0= ruleDetailCode )
+            // InternalFSM.g:2138:1: ( (lv_condition_9_0= ruleDetailCode ) )
+            // InternalFSM.g:2139:1: (lv_condition_9_0= ruleDetailCode )
             {
-            // InternalFSM.g:2101:1: (lv_condition_9_0= ruleDetailCode )
-            // InternalFSM.g:2102:3: lv_condition_9_0= ruleDetailCode
+            // InternalFSM.g:2139:1: (lv_condition_9_0= ruleDetailCode )
+            // InternalFSM.g:2140:3: lv_condition_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
@@ -5232,26 +5357,26 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2118:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
-            int alt45=2;
-            int LA45_0 = input.LA(1);
+            // InternalFSM.g:2156:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt46=2;
+            int LA46_0 = input.LA(1);
 
-            if ( (LA45_0==34) ) {
-                alt45=1;
+            if ( (LA46_0==34) ) {
+                alt46=1;
             }
-            switch (alt45) {
+            switch (alt46) {
                 case 1 :
-                    // InternalFSM.g:2118:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalFSM.g:2156:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
                     otherlv_10=(Token)match(input,34,FOLLOW_29); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0());
                         
-                    // InternalFSM.g:2122:1: ( (lv_action_11_0= ruleDetailCode ) )
-                    // InternalFSM.g:2123:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalFSM.g:2160:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalFSM.g:2161:1: (lv_action_11_0= ruleDetailCode )
                     {
-                    // InternalFSM.g:2123:1: (lv_action_11_0= ruleDetailCode )
-                    // InternalFSM.g:2124:3: lv_action_11_0= ruleDetailCode
+                    // InternalFSM.g:2161:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalFSM.g:2162:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -5309,7 +5434,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalFSM.g:2152:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
+    // InternalFSM.g:2190:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
     public final EObject entryRuleRefinedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -5317,8 +5442,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2153:2: (iv_ruleRefinedTransition= ruleRefinedTransition EOF )
-            // InternalFSM.g:2154:2: iv_ruleRefinedTransition= ruleRefinedTransition EOF
+            // InternalFSM.g:2191:2: (iv_ruleRefinedTransition= ruleRefinedTransition EOF )
+            // InternalFSM.g:2192:2: iv_ruleRefinedTransition= ruleRefinedTransition EOF
             {
              newCompositeNode(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5345,7 +5470,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefinedTransition"
-    // InternalFSM.g:2161:1: ruleRefinedTransition returns [EObject current=null] : (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) ;
+    // InternalFSM.g:2199:1: ruleRefinedTransition returns [EObject current=null] : (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) ;
     public final EObject ruleRefinedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -5361,21 +5486,21 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2164:28: ( (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) )
-            // InternalFSM.g:2165:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
+            // InternalFSM.g:2202:28: ( (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) )
+            // InternalFSM.g:2203:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
             {
-            // InternalFSM.g:2165:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
-            // InternalFSM.g:2165:3: otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}'
+            // InternalFSM.g:2203:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
+            // InternalFSM.g:2203:3: otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}'
             {
             otherlv_0=(Token)match(input,39,FOLLOW_5); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0());
                 
-            // InternalFSM.g:2169:1: ( ( ruleFQN ) )
-            // InternalFSM.g:2170:1: ( ruleFQN )
+            // InternalFSM.g:2207:1: ( ( ruleFQN ) )
+            // InternalFSM.g:2208:1: ( ruleFQN )
             {
-            // InternalFSM.g:2170:1: ( ruleFQN )
-            // InternalFSM.g:2171:3: ruleFQN
+            // InternalFSM.g:2208:1: ( ruleFQN )
+            // InternalFSM.g:2209:3: ruleFQN
             {
 
             			if (current==null) {
@@ -5399,19 +5524,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2184:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt46=2;
-            int LA46_0 = input.LA(1);
+            // InternalFSM.g:2222:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt47=2;
+            int LA47_0 = input.LA(1);
 
-            if ( (LA46_0==56) ) {
-                alt46=1;
+            if ( (LA47_0==56) ) {
+                alt47=1;
             }
-            switch (alt46) {
+            switch (alt47) {
                 case 1 :
-                    // InternalFSM.g:2185:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalFSM.g:2223:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalFSM.g:2185:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalFSM.g:2186:3: lv_docu_2_0= ruleDocumentation
+                    // InternalFSM.g:2223:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalFSM.g:2224:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -5449,11 +5574,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getRefinedTransitionAccess().getActionKeyword_4());
                 
-            // InternalFSM.g:2210:1: ( (lv_action_5_0= ruleDetailCode ) )
-            // InternalFSM.g:2211:1: (lv_action_5_0= ruleDetailCode )
+            // InternalFSM.g:2248:1: ( (lv_action_5_0= ruleDetailCode ) )
+            // InternalFSM.g:2249:1: (lv_action_5_0= ruleDetailCode )
             {
-            // InternalFSM.g:2211:1: (lv_action_5_0= ruleDetailCode )
-            // InternalFSM.g:2212:3: lv_action_5_0= ruleDetailCode
+            // InternalFSM.g:2249:1: (lv_action_5_0= ruleDetailCode )
+            // InternalFSM.g:2250:3: lv_action_5_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
@@ -5505,7 +5630,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalFSM.g:2240:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
+    // InternalFSM.g:2278:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
     public final EObject entryRuleTransitionTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5513,8 +5638,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2241:2: (iv_ruleTransitionTerminal= ruleTransitionTerminal EOF )
-            // InternalFSM.g:2242:2: iv_ruleTransitionTerminal= ruleTransitionTerminal EOF
+            // InternalFSM.g:2279:2: (iv_ruleTransitionTerminal= ruleTransitionTerminal EOF )
+            // InternalFSM.g:2280:2: iv_ruleTransitionTerminal= ruleTransitionTerminal EOF
             {
              newCompositeNode(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5541,7 +5666,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransitionTerminal"
-    // InternalFSM.g:2249:1: ruleTransitionTerminal returns [EObject current=null] : (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) ;
+    // InternalFSM.g:2287:1: ruleTransitionTerminal returns [EObject current=null] : (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) ;
     public final EObject ruleTransitionTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5557,25 +5682,25 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2252:28: ( (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) )
-            // InternalFSM.g:2253:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
+            // InternalFSM.g:2290:28: ( (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) )
+            // InternalFSM.g:2291:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
             {
-            // InternalFSM.g:2253:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
-            int alt47=4;
+            // InternalFSM.g:2291:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
+            int alt48=4;
             switch ( input.LA(1) ) {
             case RULE_ID:
                 {
-                int LA47_1 = input.LA(2);
+                int LA48_1 = input.LA(2);
 
-                if ( (LA47_1==EOF||(LA47_1>=16 && LA47_1<=17)||LA47_1==19||(LA47_1>=24 && LA47_1<=30)||LA47_1==33||LA47_1==39||LA47_1==56) ) {
-                    alt47=1;
+                if ( (LA48_1==41) ) {
+                    alt48=3;
                 }
-                else if ( (LA47_1==41) ) {
-                    alt47=3;
+                else if ( (LA48_1==EOF||(LA48_1>=16 && LA48_1<=17)||LA48_1==19||(LA48_1>=24 && LA48_1<=30)||LA48_1==33||LA48_1==39||LA48_1==56) ) {
+                    alt48=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 47, 1, input);
+                        new NoViableAltException("", 48, 1, input);
 
                     throw nvae;
                 }
@@ -5583,24 +5708,24 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case 40:
                 {
-                alt47=2;
+                alt48=2;
                 }
                 break;
             case 42:
                 {
-                alt47=4;
+                alt48=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 47, 0, input);
+                    new NoViableAltException("", 48, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt47) {
+            switch (alt48) {
                 case 1 :
-                    // InternalFSM.g:2254:5: this_StateTerminal_0= ruleStateTerminal
+                    // InternalFSM.g:2292:5: this_StateTerminal_0= ruleStateTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
@@ -5618,7 +5743,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2264:5: this_TrPointTerminal_1= ruleTrPointTerminal
+                    // InternalFSM.g:2302:5: this_TrPointTerminal_1= ruleTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
@@ -5636,7 +5761,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:2274:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
+                    // InternalFSM.g:2312:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
@@ -5654,7 +5779,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:2284:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
+                    // InternalFSM.g:2322:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
@@ -5692,7 +5817,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalFSM.g:2300:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
+    // InternalFSM.g:2338:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
     public final EObject entryRuleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5700,8 +5825,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2301:2: (iv_ruleStateTerminal= ruleStateTerminal EOF )
-            // InternalFSM.g:2302:2: iv_ruleStateTerminal= ruleStateTerminal EOF
+            // InternalFSM.g:2339:2: (iv_ruleStateTerminal= ruleStateTerminal EOF )
+            // InternalFSM.g:2340:2: iv_ruleStateTerminal= ruleStateTerminal EOF
             {
              newCompositeNode(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5728,7 +5853,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalFSM.g:2309:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
+    // InternalFSM.g:2347:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
     public final EObject ruleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5737,14 +5862,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2312:28: ( ( (otherlv_0= RULE_ID ) ) )
-            // InternalFSM.g:2313:1: ( (otherlv_0= RULE_ID ) )
+            // InternalFSM.g:2350:28: ( ( (otherlv_0= RULE_ID ) ) )
+            // InternalFSM.g:2351:1: ( (otherlv_0= RULE_ID ) )
             {
-            // InternalFSM.g:2313:1: ( (otherlv_0= RULE_ID ) )
-            // InternalFSM.g:2314:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2351:1: ( (otherlv_0= RULE_ID ) )
+            // InternalFSM.g:2352:1: (otherlv_0= RULE_ID )
             {
-            // InternalFSM.g:2314:1: (otherlv_0= RULE_ID )
-            // InternalFSM.g:2315:3: otherlv_0= RULE_ID
+            // InternalFSM.g:2352:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2353:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -5779,7 +5904,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalFSM.g:2334:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
+    // InternalFSM.g:2372:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
     public final EObject entryRuleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5787,8 +5912,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2335:2: (iv_ruleTrPointTerminal= ruleTrPointTerminal EOF )
-            // InternalFSM.g:2336:2: iv_ruleTrPointTerminal= ruleTrPointTerminal EOF
+            // InternalFSM.g:2373:2: (iv_ruleTrPointTerminal= ruleTrPointTerminal EOF )
+            // InternalFSM.g:2374:2: iv_ruleTrPointTerminal= ruleTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5815,7 +5940,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTrPointTerminal"
-    // InternalFSM.g:2343:1: ruleTrPointTerminal returns [EObject current=null] : (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalFSM.g:2381:1: ruleTrPointTerminal returns [EObject current=null] : (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5825,21 +5950,21 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2346:28: ( (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalFSM.g:2347:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
+            // InternalFSM.g:2384:28: ( (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalFSM.g:2385:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalFSM.g:2347:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
-            // InternalFSM.g:2347:3: otherlv_0= 'my' ( (otherlv_1= RULE_ID ) )
+            // InternalFSM.g:2385:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
+            // InternalFSM.g:2385:3: otherlv_0= 'my' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,40,FOLLOW_5); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTrPointTerminalAccess().getMyKeyword_0());
                 
-            // InternalFSM.g:2351:1: ( (otherlv_1= RULE_ID ) )
-            // InternalFSM.g:2352:1: (otherlv_1= RULE_ID )
+            // InternalFSM.g:2389:1: ( (otherlv_1= RULE_ID ) )
+            // InternalFSM.g:2390:1: (otherlv_1= RULE_ID )
             {
-            // InternalFSM.g:2352:1: (otherlv_1= RULE_ID )
-            // InternalFSM.g:2353:3: otherlv_1= RULE_ID
+            // InternalFSM.g:2390:1: (otherlv_1= RULE_ID )
+            // InternalFSM.g:2391:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -5877,7 +6002,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalFSM.g:2372:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
+    // InternalFSM.g:2410:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
     public final EObject entryRuleSubStateTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5885,8 +6010,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2373:2: (iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF )
-            // InternalFSM.g:2374:2: iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF
+            // InternalFSM.g:2411:2: (iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF )
+            // InternalFSM.g:2412:2: iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5913,7 +6038,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSubStateTrPointTerminal"
-    // InternalFSM.g:2381:1: ruleSubStateTrPointTerminal returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalFSM.g:2419:1: ruleSubStateTrPointTerminal returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleSubStateTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -5924,17 +6049,17 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2384:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalFSM.g:2385:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalFSM.g:2422:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalFSM.g:2423:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalFSM.g:2385:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
-            // InternalFSM.g:2385:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2423:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalFSM.g:2423:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
             {
-            // InternalFSM.g:2385:2: ( (otherlv_0= RULE_ID ) )
-            // InternalFSM.g:2386:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2423:2: ( (otherlv_0= RULE_ID ) )
+            // InternalFSM.g:2424:1: (otherlv_0= RULE_ID )
             {
-            // InternalFSM.g:2386:1: (otherlv_0= RULE_ID )
-            // InternalFSM.g:2387:3: otherlv_0= RULE_ID
+            // InternalFSM.g:2424:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2425:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -5955,11 +6080,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1());
                 
-            // InternalFSM.g:2402:1: ( (otherlv_2= RULE_ID ) )
-            // InternalFSM.g:2403:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2440:1: ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2441:1: (otherlv_2= RULE_ID )
             {
-            // InternalFSM.g:2403:1: (otherlv_2= RULE_ID )
-            // InternalFSM.g:2404:3: otherlv_2= RULE_ID
+            // InternalFSM.g:2441:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2442:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -5997,7 +6122,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalFSM.g:2423:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
+    // InternalFSM.g:2461:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
     public final EObject entryRuleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -6005,8 +6130,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2424:2: (iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF )
-            // InternalFSM.g:2425:2: iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF
+            // InternalFSM.g:2462:2: (iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF )
+            // InternalFSM.g:2463:2: iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF
             {
              newCompositeNode(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -6033,7 +6158,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleChoicepointTerminal"
-    // InternalFSM.g:2432:1: ruleChoicepointTerminal returns [EObject current=null] : (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalFSM.g:2470:1: ruleChoicepointTerminal returns [EObject current=null] : (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -6043,21 +6168,21 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2435:28: ( (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalFSM.g:2436:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
+            // InternalFSM.g:2473:28: ( (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalFSM.g:2474:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalFSM.g:2436:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
-            // InternalFSM.g:2436:3: otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) )
+            // InternalFSM.g:2474:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
+            // InternalFSM.g:2474:3: otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,42,FOLLOW_5); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0());
                 
-            // InternalFSM.g:2440:1: ( (otherlv_1= RULE_ID ) )
-            // InternalFSM.g:2441:1: (otherlv_1= RULE_ID )
+            // InternalFSM.g:2478:1: ( (otherlv_1= RULE_ID ) )
+            // InternalFSM.g:2479:1: (otherlv_1= RULE_ID )
             {
-            // InternalFSM.g:2441:1: (otherlv_1= RULE_ID )
-            // InternalFSM.g:2442:3: otherlv_1= RULE_ID
+            // InternalFSM.g:2479:1: (otherlv_1= RULE_ID )
+            // InternalFSM.g:2480:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -6095,7 +6220,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalFSM.g:2461:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
+    // InternalFSM.g:2499:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
     public final EObject entryRuleTrigger() throws RecognitionException {
         EObject current = null;
 
@@ -6103,8 +6228,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2462:2: (iv_ruleTrigger= ruleTrigger EOF )
-            // InternalFSM.g:2463:2: iv_ruleTrigger= ruleTrigger EOF
+            // InternalFSM.g:2500:2: (iv_ruleTrigger= ruleTrigger EOF )
+            // InternalFSM.g:2501:2: iv_ruleTrigger= ruleTrigger EOF
             {
              newCompositeNode(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -6131,7 +6256,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTrigger"
-    // InternalFSM.g:2470:1: ruleTrigger returns [EObject current=null] : (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) ;
+    // InternalFSM.g:2508:1: ruleTrigger returns [EObject current=null] : (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) ;
     public final EObject ruleTrigger() throws RecognitionException {
         EObject current = null;
 
@@ -6148,21 +6273,21 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2473:28: ( (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) )
-            // InternalFSM.g:2474:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
+            // InternalFSM.g:2511:28: ( (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) )
+            // InternalFSM.g:2512:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
             {
-            // InternalFSM.g:2474:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
-            // InternalFSM.g:2474:3: otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>'
+            // InternalFSM.g:2512:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
+            // InternalFSM.g:2512:3: otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>'
             {
             otherlv_0=(Token)match(input,43,FOLLOW_5); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTriggerAccess().getLessThanSignKeyword_0());
                 
-            // InternalFSM.g:2478:1: ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) )
-            // InternalFSM.g:2479:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
+            // InternalFSM.g:2516:1: ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) )
+            // InternalFSM.g:2517:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
             {
-            // InternalFSM.g:2479:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
-            // InternalFSM.g:2480:3: lv_msgFromIfPairs_1_0= ruleMessageFromIf
+            // InternalFSM.g:2517:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
+            // InternalFSM.g:2518:3: lv_msgFromIfPairs_1_0= ruleMessageFromIf
             {
              
             	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
@@ -6189,30 +6314,30 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2496:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
-            loop48:
+            // InternalFSM.g:2534:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
+            loop49:
             do {
-                int alt48=2;
-                int LA48_0 = input.LA(1);
+                int alt49=2;
+                int LA49_0 = input.LA(1);
 
-                if ( (LA48_0==44) ) {
-                    alt48=1;
+                if ( (LA49_0==44) ) {
+                    alt49=1;
                 }
 
 
-                switch (alt48) {
+                switch (alt49) {
             	case 1 :
-            	    // InternalFSM.g:2496:4: otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalFSM.g:2534:4: otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
             	    {
             	    otherlv_2=(Token)match(input,44,FOLLOW_5); 
 
             	        	newLeafNode(otherlv_2, grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0());
             	        
-            	    // InternalFSM.g:2500:1: ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
-            	    // InternalFSM.g:2501:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
+            	    // InternalFSM.g:2538:1: ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalFSM.g:2539:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
             	    {
-            	    // InternalFSM.g:2501:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
-            	    // InternalFSM.g:2502:3: lv_msgFromIfPairs_3_0= ruleMessageFromIf
+            	    // InternalFSM.g:2539:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
+            	    // InternalFSM.g:2540:3: lv_msgFromIfPairs_3_0= ruleMessageFromIf
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
@@ -6244,23 +6369,23 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop48;
+            	    break loop49;
                 }
             } while (true);
 
-            // InternalFSM.g:2518:4: ( (lv_guard_4_0= ruleGuard ) )?
-            int alt49=2;
-            int LA49_0 = input.LA(1);
+            // InternalFSM.g:2556:4: ( (lv_guard_4_0= ruleGuard ) )?
+            int alt50=2;
+            int LA50_0 = input.LA(1);
 
-            if ( (LA49_0==37) ) {
-                alt49=1;
+            if ( (LA50_0==37) ) {
+                alt50=1;
             }
-            switch (alt49) {
+            switch (alt50) {
                 case 1 :
-                    // InternalFSM.g:2519:1: (lv_guard_4_0= ruleGuard )
+                    // InternalFSM.g:2557:1: (lv_guard_4_0= ruleGuard )
                     {
-                    // InternalFSM.g:2519:1: (lv_guard_4_0= ruleGuard )
-                    // InternalFSM.g:2520:3: lv_guard_4_0= ruleGuard
+                    // InternalFSM.g:2557:1: (lv_guard_4_0= ruleGuard )
+                    // InternalFSM.g:2558:3: lv_guard_4_0= ruleGuard
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
@@ -6315,7 +6440,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalFSM.g:2548:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
+    // InternalFSM.g:2586:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
     public final EObject entryRuleMessageFromIf() throws RecognitionException {
         EObject current = null;
 
@@ -6323,8 +6448,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2549:2: (iv_ruleMessageFromIf= ruleMessageFromIf EOF )
-            // InternalFSM.g:2550:2: iv_ruleMessageFromIf= ruleMessageFromIf EOF
+            // InternalFSM.g:2587:2: (iv_ruleMessageFromIf= ruleMessageFromIf EOF )
+            // InternalFSM.g:2588:2: iv_ruleMessageFromIf= ruleMessageFromIf EOF
             {
              newCompositeNode(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -6351,7 +6476,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleMessageFromIf"
-    // InternalFSM.g:2557:1: ruleMessageFromIf returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalFSM.g:2595:1: ruleMessageFromIf returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleMessageFromIf() throws RecognitionException {
         EObject current = null;
 
@@ -6362,17 +6487,17 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2560:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalFSM.g:2561:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
+            // InternalFSM.g:2598:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalFSM.g:2599:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalFSM.g:2561:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
-            // InternalFSM.g:2561:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2599:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
+            // InternalFSM.g:2599:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) )
             {
-            // InternalFSM.g:2561:2: ( (otherlv_0= RULE_ID ) )
-            // InternalFSM.g:2562:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2599:2: ( (otherlv_0= RULE_ID ) )
+            // InternalFSM.g:2600:1: (otherlv_0= RULE_ID )
             {
-            // InternalFSM.g:2562:1: (otherlv_0= RULE_ID )
-            // InternalFSM.g:2563:3: otherlv_0= RULE_ID
+            // InternalFSM.g:2600:1: (otherlv_0= RULE_ID )
+            // InternalFSM.g:2601:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -6393,11 +6518,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getMessageFromIfAccess().getColonKeyword_1());
                 
-            // InternalFSM.g:2578:1: ( (otherlv_2= RULE_ID ) )
-            // InternalFSM.g:2579:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2616:1: ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2617:1: (otherlv_2= RULE_ID )
             {
-            // InternalFSM.g:2579:1: (otherlv_2= RULE_ID )
-            // InternalFSM.g:2580:3: otherlv_2= RULE_ID
+            // InternalFSM.g:2617:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2618:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -6435,7 +6560,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalFSM.g:2601:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
+    // InternalFSM.g:2639:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
     public final EObject entryRuleGuard() throws RecognitionException {
         EObject current = null;
 
@@ -6443,8 +6568,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2602:2: (iv_ruleGuard= ruleGuard EOF )
-            // InternalFSM.g:2603:2: iv_ruleGuard= ruleGuard EOF
+            // InternalFSM.g:2640:2: (iv_ruleGuard= ruleGuard EOF )
+            // InternalFSM.g:2641:2: iv_ruleGuard= ruleGuard EOF
             {
              newCompositeNode(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -6471,7 +6596,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleGuard"
-    // InternalFSM.g:2610:1: ruleGuard returns [EObject current=null] : (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) ;
+    // InternalFSM.g:2648:1: ruleGuard returns [EObject current=null] : (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) ;
     public final EObject ruleGuard() throws RecognitionException {
         EObject current = null;
 
@@ -6482,21 +6607,21 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2613:28: ( (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) )
-            // InternalFSM.g:2614:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
+            // InternalFSM.g:2651:28: ( (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) )
+            // InternalFSM.g:2652:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
             {
-            // InternalFSM.g:2614:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
-            // InternalFSM.g:2614:3: otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) )
+            // InternalFSM.g:2652:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
+            // InternalFSM.g:2652:3: otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) )
             {
             otherlv_0=(Token)match(input,37,FOLLOW_40); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getGuardAccess().getGuardKeyword_0());
                 
-            // InternalFSM.g:2618:1: ( (lv_guard_1_0= ruleDetailCode ) )
-            // InternalFSM.g:2619:1: (lv_guard_1_0= ruleDetailCode )
+            // InternalFSM.g:2656:1: ( (lv_guard_1_0= ruleDetailCode ) )
+            // InternalFSM.g:2657:1: (lv_guard_1_0= ruleDetailCode )
             {
-            // InternalFSM.g:2619:1: (lv_guard_1_0= ruleDetailCode )
-            // InternalFSM.g:2620:3: lv_guard_1_0= ruleDetailCode
+            // InternalFSM.g:2657:1: (lv_guard_1_0= ruleDetailCode )
+            // InternalFSM.g:2658:3: lv_guard_1_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
@@ -6544,7 +6669,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalFSM.g:2646:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
+    // InternalFSM.g:2684:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
     public final EObject entryRuleSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -6552,8 +6677,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2647:2: (iv_ruleSemanticsRule= ruleSemanticsRule EOF )
-            // InternalFSM.g:2648:2: iv_ruleSemanticsRule= ruleSemanticsRule EOF
+            // InternalFSM.g:2685:2: (iv_ruleSemanticsRule= ruleSemanticsRule EOF )
+            // InternalFSM.g:2686:2: iv_ruleSemanticsRule= ruleSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6580,7 +6705,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSemanticsRule"
-    // InternalFSM.g:2655:1: ruleSemanticsRule returns [EObject current=null] : (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) ;
+    // InternalFSM.g:2693:1: ruleSemanticsRule returns [EObject current=null] : (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) ;
     public final EObject ruleSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -6592,28 +6717,28 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2658:28: ( (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) )
-            // InternalFSM.g:2659:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
+            // InternalFSM.g:2696:28: ( (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) )
+            // InternalFSM.g:2697:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
             {
-            // InternalFSM.g:2659:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
-            int alt50=2;
-            int LA50_0 = input.LA(1);
+            // InternalFSM.g:2697:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
+            int alt51=2;
+            int LA51_0 = input.LA(1);
 
-            if ( (LA50_0==46) ) {
-                alt50=1;
+            if ( (LA51_0==46) ) {
+                alt51=1;
             }
-            else if ( (LA50_0==50) ) {
-                alt50=2;
+            else if ( (LA51_0==50) ) {
+                alt51=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 50, 0, input);
+                    new NoViableAltException("", 51, 0, input);
 
                 throw nvae;
             }
-            switch (alt50) {
+            switch (alt51) {
                 case 1 :
-                    // InternalFSM.g:2660:5: this_InSemanticsRule_0= ruleInSemanticsRule
+                    // InternalFSM.g:2698:5: this_InSemanticsRule_0= ruleInSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
@@ -6631,7 +6756,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:2670:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
+                    // InternalFSM.g:2708:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
@@ -6669,7 +6794,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalFSM.g:2686:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
+    // InternalFSM.g:2724:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
     public final EObject entryRuleInSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -6677,8 +6802,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2687:2: (iv_ruleInSemanticsRule= ruleInSemanticsRule EOF )
-            // InternalFSM.g:2688:2: iv_ruleInSemanticsRule= ruleInSemanticsRule EOF
+            // InternalFSM.g:2725:2: (iv_ruleInSemanticsRule= ruleInSemanticsRule EOF )
+            // InternalFSM.g:2726:2: iv_ruleInSemanticsRule= ruleInSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6705,7 +6830,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInSemanticsRule"
-    // InternalFSM.g:2695:1: ruleInSemanticsRule returns [EObject current=null] : (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
+    // InternalFSM.g:2733:1: ruleInSemanticsRule returns [EObject current=null] : (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
     public final EObject ruleInSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -6726,11 +6851,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2698:28: ( (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
-            // InternalFSM.g:2699:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalFSM.g:2736:28: ( (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
+            // InternalFSM.g:2737:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
             {
-            // InternalFSM.g:2699:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
-            // InternalFSM.g:2699:3: otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            // InternalFSM.g:2737:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalFSM.g:2737:3: otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
             {
             otherlv_0=(Token)match(input,46,FOLLOW_24); 
 
@@ -6740,11 +6865,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1());
                 
-            // InternalFSM.g:2707:1: ( (otherlv_2= RULE_ID ) )
-            // InternalFSM.g:2708:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2745:1: ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2746:1: (otherlv_2= RULE_ID )
             {
-            // InternalFSM.g:2708:1: (otherlv_2= RULE_ID )
-            // InternalFSM.g:2709:3: otherlv_2= RULE_ID
+            // InternalFSM.g:2746:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2747:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -6761,46 +6886,46 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2720:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
-            int alt53=2;
-            int LA53_0 = input.LA(1);
+            // InternalFSM.g:2758:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            int alt54=2;
+            int LA54_0 = input.LA(1);
 
-            if ( (LA53_0==33) ) {
-                alt53=1;
+            if ( (LA54_0==33) ) {
+                alt54=1;
             }
-            switch (alt53) {
+            switch (alt54) {
                 case 1 :
-                    // InternalFSM.g:2720:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    // InternalFSM.g:2758:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
                     {
                     otherlv_3=(Token)match(input,33,FOLLOW_42); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0());
                         
-                    // InternalFSM.g:2724:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
-                    int alt52=2;
-                    int LA52_0 = input.LA(1);
+                    // InternalFSM.g:2762:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    int alt53=2;
+                    int LA53_0 = input.LA(1);
 
-                    if ( (LA52_0==46||LA52_0==50) ) {
-                        alt52=1;
+                    if ( (LA53_0==46||LA53_0==50) ) {
+                        alt53=1;
                     }
-                    else if ( (LA52_0==47) ) {
-                        alt52=2;
+                    else if ( (LA53_0==47) ) {
+                        alt53=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 52, 0, input);
+                            new NoViableAltException("", 53, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt52) {
+                    switch (alt53) {
                         case 1 :
-                            // InternalFSM.g:2724:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2762:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
                             {
-                            // InternalFSM.g:2724:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
-                            // InternalFSM.g:2725:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalFSM.g:2762:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2763:1: (lv_followUps_4_0= ruleSemanticsRule )
                             {
-                            // InternalFSM.g:2725:1: (lv_followUps_4_0= ruleSemanticsRule )
-                            // InternalFSM.g:2726:3: lv_followUps_4_0= ruleSemanticsRule
+                            // InternalFSM.g:2763:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalFSM.g:2764:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -6831,20 +6956,20 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalFSM.g:2743:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalFSM.g:2781:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
                             {
-                            // InternalFSM.g:2743:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
-                            // InternalFSM.g:2743:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
+                            // InternalFSM.g:2781:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalFSM.g:2781:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
                             {
                             otherlv_5=(Token)match(input,47,FOLLOW_43); 
 
                                 	newLeafNode(otherlv_5, grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0());
                                 
-                            // InternalFSM.g:2747:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
-                            // InternalFSM.g:2748:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalFSM.g:2785:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2786:1: (lv_followUps_6_0= ruleSemanticsRule )
                             {
-                            // InternalFSM.g:2748:1: (lv_followUps_6_0= ruleSemanticsRule )
-                            // InternalFSM.g:2749:3: lv_followUps_6_0= ruleSemanticsRule
+                            // InternalFSM.g:2786:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalFSM.g:2787:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
@@ -6871,31 +6996,31 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalFSM.g:2765:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt51=0;
-                            loop51:
+                            // InternalFSM.g:2803:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt52=0;
+                            loop52:
                             do {
-                                int alt51=2;
-                                int LA51_0 = input.LA(1);
+                                int alt52=2;
+                                int LA52_0 = input.LA(1);
 
-                                if ( (LA51_0==48) ) {
-                                    alt51=1;
+                                if ( (LA52_0==48) ) {
+                                    alt52=1;
                                 }
 
 
-                                switch (alt51) {
+                                switch (alt52) {
                             	case 1 :
-                            	    // InternalFSM.g:2765:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalFSM.g:2803:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
                             	    otherlv_7=(Token)match(input,48,FOLLOW_43); 
 
                             	        	newLeafNode(otherlv_7, grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0());
                             	        
-                            	    // InternalFSM.g:2769:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
-                            	    // InternalFSM.g:2770:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalFSM.g:2807:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalFSM.g:2808:1: (lv_followUps_8_0= ruleSemanticsRule )
                             	    {
-                            	    // InternalFSM.g:2770:1: (lv_followUps_8_0= ruleSemanticsRule )
-                            	    // InternalFSM.g:2771:3: lv_followUps_8_0= ruleSemanticsRule
+                            	    // InternalFSM.g:2808:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalFSM.g:2809:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -6927,12 +7052,12 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt51 >= 1 ) break loop51;
+                            	    if ( cnt52 >= 1 ) break loop52;
                                         EarlyExitException eee =
-                                            new EarlyExitException(51, input);
+                                            new EarlyExitException(52, input);
                                         throw eee;
                                 }
-                                cnt51++;
+                                cnt52++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,49,FOLLOW_2); 
@@ -6975,7 +7100,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalFSM.g:2799:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
+    // InternalFSM.g:2837:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
     public final EObject entryRuleOutSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -6983,8 +7108,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2800:2: (iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF )
-            // InternalFSM.g:2801:2: iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF
+            // InternalFSM.g:2838:2: (iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF )
+            // InternalFSM.g:2839:2: iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -7011,7 +7136,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleOutSemanticsRule"
-    // InternalFSM.g:2808:1: ruleOutSemanticsRule returns [EObject current=null] : (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
+    // InternalFSM.g:2846:1: ruleOutSemanticsRule returns [EObject current=null] : (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
     public final EObject ruleOutSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -7032,11 +7157,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2811:28: ( (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
-            // InternalFSM.g:2812:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalFSM.g:2849:28: ( (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
+            // InternalFSM.g:2850:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
             {
-            // InternalFSM.g:2812:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
-            // InternalFSM.g:2812:3: otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            // InternalFSM.g:2850:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalFSM.g:2850:3: otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
             {
             otherlv_0=(Token)match(input,50,FOLLOW_24); 
 
@@ -7046,11 +7171,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1());
                 
-            // InternalFSM.g:2820:1: ( (otherlv_2= RULE_ID ) )
-            // InternalFSM.g:2821:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2858:1: ( (otherlv_2= RULE_ID ) )
+            // InternalFSM.g:2859:1: (otherlv_2= RULE_ID )
             {
-            // InternalFSM.g:2821:1: (otherlv_2= RULE_ID )
-            // InternalFSM.g:2822:3: otherlv_2= RULE_ID
+            // InternalFSM.g:2859:1: (otherlv_2= RULE_ID )
+            // InternalFSM.g:2860:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -7067,46 +7192,46 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:2833:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
-            int alt56=2;
-            int LA56_0 = input.LA(1);
+            // InternalFSM.g:2871:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            int alt57=2;
+            int LA57_0 = input.LA(1);
 
-            if ( (LA56_0==33) ) {
-                alt56=1;
+            if ( (LA57_0==33) ) {
+                alt57=1;
             }
-            switch (alt56) {
+            switch (alt57) {
                 case 1 :
-                    // InternalFSM.g:2833:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    // InternalFSM.g:2871:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
                     {
                     otherlv_3=(Token)match(input,33,FOLLOW_42); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0());
                         
-                    // InternalFSM.g:2837:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
-                    int alt55=2;
-                    int LA55_0 = input.LA(1);
+                    // InternalFSM.g:2875:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    int alt56=2;
+                    int LA56_0 = input.LA(1);
 
-                    if ( (LA55_0==46||LA55_0==50) ) {
-                        alt55=1;
+                    if ( (LA56_0==46||LA56_0==50) ) {
+                        alt56=1;
                     }
-                    else if ( (LA55_0==47) ) {
-                        alt55=2;
+                    else if ( (LA56_0==47) ) {
+                        alt56=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 55, 0, input);
+                            new NoViableAltException("", 56, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt55) {
+                    switch (alt56) {
                         case 1 :
-                            // InternalFSM.g:2837:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2875:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
                             {
-                            // InternalFSM.g:2837:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
-                            // InternalFSM.g:2838:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalFSM.g:2875:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2876:1: (lv_followUps_4_0= ruleSemanticsRule )
                             {
-                            // InternalFSM.g:2838:1: (lv_followUps_4_0= ruleSemanticsRule )
-                            // InternalFSM.g:2839:3: lv_followUps_4_0= ruleSemanticsRule
+                            // InternalFSM.g:2876:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalFSM.g:2877:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -7137,20 +7262,20 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalFSM.g:2856:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalFSM.g:2894:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
                             {
-                            // InternalFSM.g:2856:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
-                            // InternalFSM.g:2856:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
+                            // InternalFSM.g:2894:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalFSM.g:2894:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
                             {
                             otherlv_5=(Token)match(input,47,FOLLOW_43); 
 
                                 	newLeafNode(otherlv_5, grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0());
                                 
-                            // InternalFSM.g:2860:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
-                            // InternalFSM.g:2861:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalFSM.g:2898:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalFSM.g:2899:1: (lv_followUps_6_0= ruleSemanticsRule )
                             {
-                            // InternalFSM.g:2861:1: (lv_followUps_6_0= ruleSemanticsRule )
-                            // InternalFSM.g:2862:3: lv_followUps_6_0= ruleSemanticsRule
+                            // InternalFSM.g:2899:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalFSM.g:2900:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
@@ -7177,31 +7302,31 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalFSM.g:2878:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt54=0;
-                            loop54:
+                            // InternalFSM.g:2916:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt55=0;
+                            loop55:
                             do {
-                                int alt54=2;
-                                int LA54_0 = input.LA(1);
+                                int alt55=2;
+                                int LA55_0 = input.LA(1);
 
-                                if ( (LA54_0==48) ) {
-                                    alt54=1;
+                                if ( (LA55_0==48) ) {
+                                    alt55=1;
                                 }
 
 
-                                switch (alt54) {
+                                switch (alt55) {
                             	case 1 :
-                            	    // InternalFSM.g:2878:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalFSM.g:2916:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
                             	    otherlv_7=(Token)match(input,48,FOLLOW_43); 
 
                             	        	newLeafNode(otherlv_7, grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0());
                             	        
-                            	    // InternalFSM.g:2882:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
-                            	    // InternalFSM.g:2883:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalFSM.g:2920:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalFSM.g:2921:1: (lv_followUps_8_0= ruleSemanticsRule )
                             	    {
-                            	    // InternalFSM.g:2883:1: (lv_followUps_8_0= ruleSemanticsRule )
-                            	    // InternalFSM.g:2884:3: lv_followUps_8_0= ruleSemanticsRule
+                            	    // InternalFSM.g:2921:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalFSM.g:2922:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -7233,12 +7358,12 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt54 >= 1 ) break loop54;
+                            	    if ( cnt55 >= 1 ) break loop55;
                                         EarlyExitException eee =
-                                            new EarlyExitException(54, input);
+                                            new EarlyExitException(55, input);
                                         throw eee;
                                 }
-                                cnt54++;
+                                cnt55++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,49,FOLLOW_2); 
@@ -7281,7 +7406,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalFSM.g:2914:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
+    // InternalFSM.g:2952:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
     public final EObject entryRuleKeyValue() throws RecognitionException {
         EObject current = null;
 
@@ -7289,8 +7414,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2915:2: (iv_ruleKeyValue= ruleKeyValue EOF )
-            // InternalFSM.g:2916:2: iv_ruleKeyValue= ruleKeyValue EOF
+            // InternalFSM.g:2953:2: (iv_ruleKeyValue= ruleKeyValue EOF )
+            // InternalFSM.g:2954:2: iv_ruleKeyValue= ruleKeyValue EOF
             {
              newCompositeNode(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -7317,7 +7442,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleKeyValue"
-    // InternalFSM.g:2923:1: ruleKeyValue returns [EObject current=null] : ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) ;
+    // InternalFSM.g:2961:1: ruleKeyValue returns [EObject current=null] : ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) ;
     public final EObject ruleKeyValue() throws RecognitionException {
         EObject current = null;
 
@@ -7329,17 +7454,17 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2926:28: ( ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) )
-            // InternalFSM.g:2927:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
+            // InternalFSM.g:2964:28: ( ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) )
+            // InternalFSM.g:2965:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
             {
-            // InternalFSM.g:2927:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
-            // InternalFSM.g:2927:2: ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) )
+            // InternalFSM.g:2965:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
+            // InternalFSM.g:2965:2: ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) )
             {
-            // InternalFSM.g:2927:2: ( (lv_key_0_0= RULE_ID ) )
-            // InternalFSM.g:2928:1: (lv_key_0_0= RULE_ID )
+            // InternalFSM.g:2965:2: ( (lv_key_0_0= RULE_ID ) )
+            // InternalFSM.g:2966:1: (lv_key_0_0= RULE_ID )
             {
-            // InternalFSM.g:2928:1: (lv_key_0_0= RULE_ID )
-            // InternalFSM.g:2929:3: lv_key_0_0= RULE_ID
+            // InternalFSM.g:2966:1: (lv_key_0_0= RULE_ID )
+            // InternalFSM.g:2967:3: lv_key_0_0= RULE_ID
             {
             lv_key_0_0=(Token)match(input,RULE_ID,FOLLOW_46); 
 
@@ -7365,11 +7490,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1());
                 
-            // InternalFSM.g:2949:1: ( (lv_value_2_0= ruleLiteral ) )
-            // InternalFSM.g:2950:1: (lv_value_2_0= ruleLiteral )
+            // InternalFSM.g:2987:1: ( (lv_value_2_0= ruleLiteral ) )
+            // InternalFSM.g:2988:1: (lv_value_2_0= ruleLiteral )
             {
-            // InternalFSM.g:2950:1: (lv_value_2_0= ruleLiteral )
-            // InternalFSM.g:2951:3: lv_value_2_0= ruleLiteral
+            // InternalFSM.g:2988:1: (lv_value_2_0= ruleLiteral )
+            // InternalFSM.g:2989:3: lv_value_2_0= ruleLiteral
             {
              
             	        newCompositeNode(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
@@ -7417,7 +7542,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationTargetType"
-    // InternalFSM.g:2977:1: entryRuleAnnotationTargetType returns [String current=null] : iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF ;
+    // InternalFSM.g:3015:1: entryRuleAnnotationTargetType returns [String current=null] : iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF ;
     public final String entryRuleAnnotationTargetType() throws RecognitionException {
         String current = null;
 
@@ -7425,8 +7550,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:2978:2: (iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF )
-            // InternalFSM.g:2979:2: iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF
+            // InternalFSM.g:3016:2: (iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF )
+            // InternalFSM.g:3017:2: iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF
             {
              newCompositeNode(grammarAccess.getAnnotationTargetTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -7453,7 +7578,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotationTargetType"
-    // InternalFSM.g:2986:1: ruleAnnotationTargetType returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ;
+    // InternalFSM.g:3024:1: ruleAnnotationTargetType returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ;
     public final AntlrDatatypeRuleToken ruleAnnotationTargetType() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -7462,8 +7587,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:2989:28: (this_ID_0= RULE_ID )
-            // InternalFSM.g:2990:5: this_ID_0= RULE_ID
+            // InternalFSM.g:3027:28: (this_ID_0= RULE_ID )
+            // InternalFSM.g:3028:5: this_ID_0= RULE_ID
             {
             this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); 
 
@@ -7490,7 +7615,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalFSM.g:3005:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
+    // InternalFSM.g:3043:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
     public final EObject entryRuleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7498,8 +7623,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3006:2: (iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF )
-            // InternalFSM.g:3007:2: iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF
+            // InternalFSM.g:3044:2: (iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF )
+            // InternalFSM.g:3045:2: iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -7526,7 +7651,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotationAttribute"
-    // InternalFSM.g:3014:1: ruleAnnotationAttribute returns [EObject current=null] : (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) ;
+    // InternalFSM.g:3052:1: ruleAnnotationAttribute returns [EObject current=null] : (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) ;
     public final EObject ruleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7538,114 +7663,114 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3017:28: ( (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) )
-            // InternalFSM.g:3018:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
+            // InternalFSM.g:3055:28: ( (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) )
+            // InternalFSM.g:3056:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
             {
-            // InternalFSM.g:3018:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
-            int alt57=2;
-            int LA57_0 = input.LA(1);
+            // InternalFSM.g:3056:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
+            int alt58=2;
+            int LA58_0 = input.LA(1);
 
-            if ( (LA57_0==52) ) {
-                int LA57_1 = input.LA(2);
+            if ( (LA58_0==52) ) {
+                int LA58_1 = input.LA(2);
 
-                if ( (LA57_1==54) ) {
-                    int LA57_3 = input.LA(3);
+                if ( (LA58_1==54) ) {
+                    int LA58_3 = input.LA(3);
 
-                    if ( (LA57_3==RULE_ID) ) {
-                        int LA57_4 = input.LA(4);
+                    if ( (LA58_3==RULE_ID) ) {
+                        int LA58_4 = input.LA(4);
 
-                        if ( (LA57_4==31) ) {
-                            int LA57_5 = input.LA(5);
+                        if ( (LA58_4==31) ) {
+                            int LA58_5 = input.LA(5);
 
-                            if ( ((LA57_5>=69 && LA57_5<=72)) ) {
-                                alt57=1;
+                            if ( ((LA58_5>=69 && LA58_5<=72)) ) {
+                                alt58=1;
                             }
-                            else if ( (LA57_5==16) ) {
-                                alt57=2;
+                            else if ( (LA58_5==16) ) {
+                                alt58=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 57, 5, input);
+                                    new NoViableAltException("", 58, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 57, 4, input);
+                                new NoViableAltException("", 58, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 57, 3, input);
+                            new NoViableAltException("", 58, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 57, 1, input);
+                        new NoViableAltException("", 58, 1, input);
 
                     throw nvae;
                 }
             }
-            else if ( (LA57_0==53) ) {
-                int LA57_2 = input.LA(2);
+            else if ( (LA58_0==53) ) {
+                int LA58_2 = input.LA(2);
 
-                if ( (LA57_2==54) ) {
-                    int LA57_3 = input.LA(3);
+                if ( (LA58_2==54) ) {
+                    int LA58_3 = input.LA(3);
 
-                    if ( (LA57_3==RULE_ID) ) {
-                        int LA57_4 = input.LA(4);
+                    if ( (LA58_3==RULE_ID) ) {
+                        int LA58_4 = input.LA(4);
 
-                        if ( (LA57_4==31) ) {
-                            int LA57_5 = input.LA(5);
+                        if ( (LA58_4==31) ) {
+                            int LA58_5 = input.LA(5);
 
-                            if ( ((LA57_5>=69 && LA57_5<=72)) ) {
-                                alt57=1;
+                            if ( ((LA58_5>=69 && LA58_5<=72)) ) {
+                                alt58=1;
                             }
-                            else if ( (LA57_5==16) ) {
-                                alt57=2;
+                            else if ( (LA58_5==16) ) {
+                                alt58=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 57, 5, input);
+                                    new NoViableAltException("", 58, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 57, 4, input);
+                                new NoViableAltException("", 58, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 57, 3, input);
+                            new NoViableAltException("", 58, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 57, 2, input);
+                        new NoViableAltException("", 58, 2, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 57, 0, input);
+                    new NoViableAltException("", 58, 0, input);
 
                 throw nvae;
             }
-            switch (alt57) {
+            switch (alt58) {
                 case 1 :
-                    // InternalFSM.g:3019:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
+                    // InternalFSM.g:3057:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
@@ -7663,7 +7788,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3029:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
+                    // InternalFSM.g:3067:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
@@ -7701,7 +7826,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalFSM.g:3045:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
+    // InternalFSM.g:3083:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
     public final EObject entryRuleSimpleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7709,8 +7834,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3046:2: (iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF )
-            // InternalFSM.g:3047:2: iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF
+            // InternalFSM.g:3084:2: (iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF )
+            // InternalFSM.g:3085:2: iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -7737,7 +7862,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSimpleAnnotationAttribute"
-    // InternalFSM.g:3054:1: ruleSimpleAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) ;
+    // InternalFSM.g:3092:1: ruleSimpleAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) ;
     public final EObject ruleSimpleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7752,37 +7877,37 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3057:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) )
-            // InternalFSM.g:3058:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
+            // InternalFSM.g:3095:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) )
+            // InternalFSM.g:3096:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
             {
-            // InternalFSM.g:3058:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
-            // InternalFSM.g:3058:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) )
+            // InternalFSM.g:3096:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
+            // InternalFSM.g:3096:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) )
             {
-            // InternalFSM.g:3058:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
-            int alt58=2;
-            int LA58_0 = input.LA(1);
+            // InternalFSM.g:3096:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt59=2;
+            int LA59_0 = input.LA(1);
 
-            if ( (LA58_0==52) ) {
-                alt58=1;
+            if ( (LA59_0==52) ) {
+                alt59=1;
             }
-            else if ( (LA58_0==53) ) {
-                alt58=2;
+            else if ( (LA59_0==53) ) {
+                alt59=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 58, 0, input);
+                    new NoViableAltException("", 59, 0, input);
 
                 throw nvae;
             }
-            switch (alt58) {
+            switch (alt59) {
                 case 1 :
-                    // InternalFSM.g:3058:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalFSM.g:3096:3: ( (lv_optional_0_0= 'optional' ) )
                     {
-                    // InternalFSM.g:3058:3: ( (lv_optional_0_0= 'optional' ) )
-                    // InternalFSM.g:3059:1: (lv_optional_0_0= 'optional' )
+                    // InternalFSM.g:3096:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalFSM.g:3097:1: (lv_optional_0_0= 'optional' )
                     {
-                    // InternalFSM.g:3059:1: (lv_optional_0_0= 'optional' )
-                    // InternalFSM.g:3060:3: lv_optional_0_0= 'optional'
+                    // InternalFSM.g:3097:1: (lv_optional_0_0= 'optional' )
+                    // InternalFSM.g:3098:3: lv_optional_0_0= 'optional'
                     {
                     lv_optional_0_0=(Token)match(input,52,FOLLOW_48); 
 
@@ -7804,7 +7929,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3074:7: otherlv_1= 'mandatory'
+                    // InternalFSM.g:3112:7: otherlv_1= 'mandatory'
                     {
                     otherlv_1=(Token)match(input,53,FOLLOW_48); 
 
@@ -7820,11 +7945,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1());
                 
-            // InternalFSM.g:3082:1: ( (lv_name_3_0= RULE_ID ) )
-            // InternalFSM.g:3083:1: (lv_name_3_0= RULE_ID )
+            // InternalFSM.g:3120:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalFSM.g:3121:1: (lv_name_3_0= RULE_ID )
             {
-            // InternalFSM.g:3083:1: (lv_name_3_0= RULE_ID )
-            // InternalFSM.g:3084:3: lv_name_3_0= RULE_ID
+            // InternalFSM.g:3121:1: (lv_name_3_0= RULE_ID )
+            // InternalFSM.g:3122:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -7850,11 +7975,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3());
                 
-            // InternalFSM.g:3104:1: ( (lv_type_5_0= ruleLiteralType ) )
-            // InternalFSM.g:3105:1: (lv_type_5_0= ruleLiteralType )
+            // InternalFSM.g:3142:1: ( (lv_type_5_0= ruleLiteralType ) )
+            // InternalFSM.g:3143:1: (lv_type_5_0= ruleLiteralType )
             {
-            // InternalFSM.g:3105:1: (lv_type_5_0= ruleLiteralType )
-            // InternalFSM.g:3106:3: lv_type_5_0= ruleLiteralType
+            // InternalFSM.g:3143:1: (lv_type_5_0= ruleLiteralType )
+            // InternalFSM.g:3144:3: lv_type_5_0= ruleLiteralType
             {
              
             	        newCompositeNode(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
@@ -7902,7 +8027,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalFSM.g:3130:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
+    // InternalFSM.g:3168:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
     public final EObject entryRuleEnumAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7910,8 +8035,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3131:2: (iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF )
-            // InternalFSM.g:3132:2: iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF
+            // InternalFSM.g:3169:2: (iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF )
+            // InternalFSM.g:3170:2: iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -7938,7 +8063,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleEnumAnnotationAttribute"
-    // InternalFSM.g:3139:1: ruleEnumAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) ;
+    // InternalFSM.g:3177:1: ruleEnumAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) ;
     public final EObject ruleEnumAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -7956,37 +8081,37 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3142:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) )
-            // InternalFSM.g:3143:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
+            // InternalFSM.g:3180:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) )
+            // InternalFSM.g:3181:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
             {
-            // InternalFSM.g:3143:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
-            // InternalFSM.g:3143:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}'
+            // InternalFSM.g:3181:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
+            // InternalFSM.g:3181:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}'
             {
-            // InternalFSM.g:3143:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
-            int alt59=2;
-            int LA59_0 = input.LA(1);
+            // InternalFSM.g:3181:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt60=2;
+            int LA60_0 = input.LA(1);
 
-            if ( (LA59_0==52) ) {
-                alt59=1;
+            if ( (LA60_0==52) ) {
+                alt60=1;
             }
-            else if ( (LA59_0==53) ) {
-                alt59=2;
+            else if ( (LA60_0==53) ) {
+                alt60=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 59, 0, input);
+                    new NoViableAltException("", 60, 0, input);
 
                 throw nvae;
             }
-            switch (alt59) {
+            switch (alt60) {
                 case 1 :
-                    // InternalFSM.g:3143:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalFSM.g:3181:3: ( (lv_optional_0_0= 'optional' ) )
                     {
-                    // InternalFSM.g:3143:3: ( (lv_optional_0_0= 'optional' ) )
-                    // InternalFSM.g:3144:1: (lv_optional_0_0= 'optional' )
+                    // InternalFSM.g:3181:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalFSM.g:3182:1: (lv_optional_0_0= 'optional' )
                     {
-                    // InternalFSM.g:3144:1: (lv_optional_0_0= 'optional' )
-                    // InternalFSM.g:3145:3: lv_optional_0_0= 'optional'
+                    // InternalFSM.g:3182:1: (lv_optional_0_0= 'optional' )
+                    // InternalFSM.g:3183:3: lv_optional_0_0= 'optional'
                     {
                     lv_optional_0_0=(Token)match(input,52,FOLLOW_48); 
 
@@ -8008,7 +8133,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3159:7: otherlv_1= 'mandatory'
+                    // InternalFSM.g:3197:7: otherlv_1= 'mandatory'
                     {
                     otherlv_1=(Token)match(input,53,FOLLOW_48); 
 
@@ -8024,11 +8149,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1());
                 
-            // InternalFSM.g:3167:1: ( (lv_name_3_0= RULE_ID ) )
-            // InternalFSM.g:3168:1: (lv_name_3_0= RULE_ID )
+            // InternalFSM.g:3205:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalFSM.g:3206:1: (lv_name_3_0= RULE_ID )
             {
-            // InternalFSM.g:3168:1: (lv_name_3_0= RULE_ID )
-            // InternalFSM.g:3169:3: lv_name_3_0= RULE_ID
+            // InternalFSM.g:3206:1: (lv_name_3_0= RULE_ID )
+            // InternalFSM.g:3207:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -8058,11 +8183,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_5, grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4());
                 
-            // InternalFSM.g:3193:1: ( (lv_values_6_0= RULE_STRING ) )
-            // InternalFSM.g:3194:1: (lv_values_6_0= RULE_STRING )
+            // InternalFSM.g:3231:1: ( (lv_values_6_0= RULE_STRING ) )
+            // InternalFSM.g:3232:1: (lv_values_6_0= RULE_STRING )
             {
-            // InternalFSM.g:3194:1: (lv_values_6_0= RULE_STRING )
-            // InternalFSM.g:3195:3: lv_values_6_0= RULE_STRING
+            // InternalFSM.g:3232:1: (lv_values_6_0= RULE_STRING )
+            // InternalFSM.g:3233:3: lv_values_6_0= RULE_STRING
             {
             lv_values_6_0=(Token)match(input,RULE_STRING,FOLLOW_51); 
 
@@ -8084,30 +8209,30 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3211:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
-            loop60:
+            // InternalFSM.g:3249:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
+            loop61:
             do {
-                int alt60=2;
-                int LA60_0 = input.LA(1);
+                int alt61=2;
+                int LA61_0 = input.LA(1);
 
-                if ( (LA60_0==48) ) {
-                    alt60=1;
+                if ( (LA61_0==48) ) {
+                    alt61=1;
                 }
 
 
-                switch (alt60) {
+                switch (alt61) {
             	case 1 :
-            	    // InternalFSM.g:3211:4: otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalFSM.g:3249:4: otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) )
             	    {
             	    otherlv_7=(Token)match(input,48,FOLLOW_50); 
 
             	        	newLeafNode(otherlv_7, grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0());
             	        
-            	    // InternalFSM.g:3215:1: ( (lv_values_8_0= RULE_STRING ) )
-            	    // InternalFSM.g:3216:1: (lv_values_8_0= RULE_STRING )
+            	    // InternalFSM.g:3253:1: ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalFSM.g:3254:1: (lv_values_8_0= RULE_STRING )
             	    {
-            	    // InternalFSM.g:3216:1: (lv_values_8_0= RULE_STRING )
-            	    // InternalFSM.g:3217:3: lv_values_8_0= RULE_STRING
+            	    // InternalFSM.g:3254:1: (lv_values_8_0= RULE_STRING )
+            	    // InternalFSM.g:3255:3: lv_values_8_0= RULE_STRING
             	    {
             	    lv_values_8_0=(Token)match(input,RULE_STRING,FOLLOW_51); 
 
@@ -8134,7 +8259,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop60;
+            	    break loop61;
                 }
             } while (true);
 
@@ -8163,7 +8288,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalFSM.g:3247:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
+    // InternalFSM.g:3285:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
     public final String entryRuleImportedFQN() throws RecognitionException {
         String current = null;
 
@@ -8171,8 +8296,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3248:2: (iv_ruleImportedFQN= ruleImportedFQN EOF )
-            // InternalFSM.g:3249:2: iv_ruleImportedFQN= ruleImportedFQN EOF
+            // InternalFSM.g:3286:2: (iv_ruleImportedFQN= ruleImportedFQN EOF )
+            // InternalFSM.g:3287:2: iv_ruleImportedFQN= ruleImportedFQN EOF
             {
              newCompositeNode(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -8199,7 +8324,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleImportedFQN"
-    // InternalFSM.g:3256:1: ruleImportedFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FQN_0= ruleFQN (kw= '.*' )? ) ;
+    // InternalFSM.g:3294:1: ruleImportedFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FQN_0= ruleFQN (kw= '.*' )? ) ;
     public final AntlrDatatypeRuleToken ruleImportedFQN() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -8210,11 +8335,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3259:28: ( (this_FQN_0= ruleFQN (kw= '.*' )? ) )
-            // InternalFSM.g:3260:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
+            // InternalFSM.g:3297:28: ( (this_FQN_0= ruleFQN (kw= '.*' )? ) )
+            // InternalFSM.g:3298:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
             {
-            // InternalFSM.g:3260:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
-            // InternalFSM.g:3261:5: this_FQN_0= ruleFQN (kw= '.*' )?
+            // InternalFSM.g:3298:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
+            // InternalFSM.g:3299:5: this_FQN_0= ruleFQN (kw= '.*' )?
             {
              
                     newCompositeNode(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
@@ -8230,16 +8355,16 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
              
                     afterParserOrEnumRuleCall();
                 
-            // InternalFSM.g:3271:1: (kw= '.*' )?
-            int alt61=2;
-            int LA61_0 = input.LA(1);
+            // InternalFSM.g:3309:1: (kw= '.*' )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
 
-            if ( (LA61_0==55) ) {
-                alt61=1;
+            if ( (LA62_0==55) ) {
+                alt62=1;
             }
-            switch (alt61) {
+            switch (alt62) {
                 case 1 :
-                    // InternalFSM.g:3272:2: kw= '.*'
+                    // InternalFSM.g:3310:2: kw= '.*'
                     {
                     kw=(Token)match(input,55,FOLLOW_2); 
 
@@ -8273,7 +8398,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalFSM.g:3285:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
+    // InternalFSM.g:3323:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
     public final EObject entryRuleDocumentation() throws RecognitionException {
         EObject current = null;
 
@@ -8281,8 +8406,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3286:2: (iv_ruleDocumentation= ruleDocumentation EOF )
-            // InternalFSM.g:3287:2: iv_ruleDocumentation= ruleDocumentation EOF
+            // InternalFSM.g:3324:2: (iv_ruleDocumentation= ruleDocumentation EOF )
+            // InternalFSM.g:3325:2: iv_ruleDocumentation= ruleDocumentation EOF
             {
              newCompositeNode(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -8309,7 +8434,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDocumentation"
-    // InternalFSM.g:3294:1: ruleDocumentation returns [EObject current=null] : ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) ;
+    // InternalFSM.g:3332:1: ruleDocumentation returns [EObject current=null] : ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) ;
     public final EObject ruleDocumentation() throws RecognitionException {
         EObject current = null;
 
@@ -8320,14 +8445,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3297:28: ( ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) )
-            // InternalFSM.g:3298:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
+            // InternalFSM.g:3335:28: ( ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) )
+            // InternalFSM.g:3336:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
             {
-            // InternalFSM.g:3298:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
-            // InternalFSM.g:3298:2: () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']'
+            // InternalFSM.g:3336:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
+            // InternalFSM.g:3336:2: () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']'
             {
-            // InternalFSM.g:3298:2: ()
-            // InternalFSM.g:3299:5: 
+            // InternalFSM.g:3336:2: ()
+            // InternalFSM.g:3337:5: 
             {
 
                     current = forceCreateModelElement(
@@ -8341,23 +8466,23 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1());
                 
-            // InternalFSM.g:3308:1: ( (lv_lines_2_0= RULE_STRING ) )*
-            loop62:
+            // InternalFSM.g:3346:1: ( (lv_lines_2_0= RULE_STRING ) )*
+            loop63:
             do {
-                int alt62=2;
-                int LA62_0 = input.LA(1);
+                int alt63=2;
+                int LA63_0 = input.LA(1);
 
-                if ( (LA62_0==RULE_STRING) ) {
-                    alt62=1;
+                if ( (LA63_0==RULE_STRING) ) {
+                    alt63=1;
                 }
 
 
-                switch (alt62) {
+                switch (alt63) {
             	case 1 :
-            	    // InternalFSM.g:3309:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalFSM.g:3347:1: (lv_lines_2_0= RULE_STRING )
             	    {
-            	    // InternalFSM.g:3309:1: (lv_lines_2_0= RULE_STRING )
-            	    // InternalFSM.g:3310:3: lv_lines_2_0= RULE_STRING
+            	    // InternalFSM.g:3347:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalFSM.g:3348:3: lv_lines_2_0= RULE_STRING
             	    {
             	    lv_lines_2_0=(Token)match(input,RULE_STRING,FOLLOW_53); 
 
@@ -8381,7 +8506,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop62;
+            	    break loop63;
                 }
             } while (true);
 
@@ -8410,7 +8535,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalFSM.g:3342:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+    // InternalFSM.g:3380:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
     public final EObject entryRuleLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8418,8 +8543,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3343:2: (iv_ruleLiteral= ruleLiteral EOF )
-            // InternalFSM.g:3344:2: iv_ruleLiteral= ruleLiteral EOF
+            // InternalFSM.g:3381:2: (iv_ruleLiteral= ruleLiteral EOF )
+            // InternalFSM.g:3382:2: iv_ruleLiteral= ruleLiteral EOF
             {
              newCompositeNode(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -8446,7 +8571,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLiteral"
-    // InternalFSM.g:3351:1: ruleLiteral returns [EObject current=null] : (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) ;
+    // InternalFSM.g:3389:1: ruleLiteral returns [EObject current=null] : (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) ;
     public final EObject ruleLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8460,16 +8585,16 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3354:28: ( (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) )
-            // InternalFSM.g:3355:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
+            // InternalFSM.g:3392:28: ( (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) )
+            // InternalFSM.g:3393:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
             {
-            // InternalFSM.g:3355:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
-            int alt63=3;
+            // InternalFSM.g:3393:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
+            int alt64=3;
             switch ( input.LA(1) ) {
             case 58:
             case 59:
                 {
-                alt63=1;
+                alt64=1;
                 }
                 break;
             case RULE_INT:
@@ -8477,24 +8602,24 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             case 60:
             case 61:
                 {
-                alt63=2;
+                alt64=2;
                 }
                 break;
             case RULE_STRING:
                 {
-                alt63=3;
+                alt64=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 63, 0, input);
+                    new NoViableAltException("", 64, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt63) {
+            switch (alt64) {
                 case 1 :
-                    // InternalFSM.g:3356:5: this_BooleanLiteral_0= ruleBooleanLiteral
+                    // InternalFSM.g:3394:5: this_BooleanLiteral_0= ruleBooleanLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
@@ -8512,7 +8637,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3366:5: this_NumberLiteral_1= ruleNumberLiteral
+                    // InternalFSM.g:3404:5: this_NumberLiteral_1= ruleNumberLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
@@ -8530,7 +8655,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:3376:5: this_StringLiteral_2= ruleStringLiteral
+                    // InternalFSM.g:3414:5: this_StringLiteral_2= ruleStringLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
@@ -8568,7 +8693,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalFSM.g:3392:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
+    // InternalFSM.g:3430:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
     public final EObject entryRuleBooleanLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8576,8 +8701,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3393:2: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF )
-            // InternalFSM.g:3394:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF
+            // InternalFSM.g:3431:2: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF )
+            // InternalFSM.g:3432:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF
             {
              newCompositeNode(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -8604,7 +8729,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleBooleanLiteral"
-    // InternalFSM.g:3401:1: ruleBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
+    // InternalFSM.g:3439:1: ruleBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
     public final EObject ruleBooleanLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8614,14 +8739,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3404:28: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
-            // InternalFSM.g:3405:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalFSM.g:3442:28: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
+            // InternalFSM.g:3443:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
             {
-            // InternalFSM.g:3405:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
-            // InternalFSM.g:3405:2: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            // InternalFSM.g:3443:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalFSM.g:3443:2: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
             {
-            // InternalFSM.g:3405:2: ()
-            // InternalFSM.g:3406:5: 
+            // InternalFSM.g:3443:2: ()
+            // InternalFSM.g:3444:5: 
             {
 
                     current = forceCreateModelElement(
@@ -8631,25 +8756,25 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3411:2: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
-            int alt64=2;
-            int LA64_0 = input.LA(1);
+            // InternalFSM.g:3449:2: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            int alt65=2;
+            int LA65_0 = input.LA(1);
 
-            if ( (LA64_0==58) ) {
-                alt64=1;
+            if ( (LA65_0==58) ) {
+                alt65=1;
             }
-            else if ( (LA64_0==59) ) {
-                alt64=2;
+            else if ( (LA65_0==59) ) {
+                alt65=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 64, 0, input);
+                    new NoViableAltException("", 65, 0, input);
 
                 throw nvae;
             }
-            switch (alt64) {
+            switch (alt65) {
                 case 1 :
-                    // InternalFSM.g:3411:4: otherlv_1= 'false'
+                    // InternalFSM.g:3449:4: otherlv_1= 'false'
                     {
                     otherlv_1=(Token)match(input,58,FOLLOW_2); 
 
@@ -8659,13 +8784,13 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3416:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalFSM.g:3454:6: ( (lv_isTrue_2_0= 'true' ) )
                     {
-                    // InternalFSM.g:3416:6: ( (lv_isTrue_2_0= 'true' ) )
-                    // InternalFSM.g:3417:1: (lv_isTrue_2_0= 'true' )
+                    // InternalFSM.g:3454:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalFSM.g:3455:1: (lv_isTrue_2_0= 'true' )
                     {
-                    // InternalFSM.g:3417:1: (lv_isTrue_2_0= 'true' )
-                    // InternalFSM.g:3418:3: lv_isTrue_2_0= 'true'
+                    // InternalFSM.g:3455:1: (lv_isTrue_2_0= 'true' )
+                    // InternalFSM.g:3456:3: lv_isTrue_2_0= 'true'
                     {
                     lv_isTrue_2_0=(Token)match(input,59,FOLLOW_2); 
 
@@ -8710,7 +8835,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalFSM.g:3439:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
+    // InternalFSM.g:3477:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
     public final EObject entryRuleNumberLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8718,8 +8843,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3440:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
-            // InternalFSM.g:3441:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
+            // InternalFSM.g:3478:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
+            // InternalFSM.g:3479:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
             {
              newCompositeNode(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -8746,7 +8871,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleNumberLiteral"
-    // InternalFSM.g:3448:1: ruleNumberLiteral returns [EObject current=null] : (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) ;
+    // InternalFSM.g:3486:1: ruleNumberLiteral returns [EObject current=null] : (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) ;
     public final EObject ruleNumberLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8758,35 +8883,35 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3451:28: ( (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) )
-            // InternalFSM.g:3452:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
+            // InternalFSM.g:3489:28: ( (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) )
+            // InternalFSM.g:3490:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
             {
-            // InternalFSM.g:3452:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
-            int alt65=2;
+            // InternalFSM.g:3490:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
+            int alt66=2;
             switch ( input.LA(1) ) {
             case 60:
                 {
-                int LA65_1 = input.LA(2);
+                int LA66_1 = input.LA(2);
 
-                if ( (LA65_1==RULE_INT) ) {
-                    int LA65_3 = input.LA(3);
+                if ( (LA66_1==RULE_INT) ) {
+                    int LA66_3 = input.LA(3);
 
-                    if ( (LA65_3==EOF) ) {
-                        alt65=1;
+                    if ( (LA66_3==62) ) {
+                        alt66=2;
                     }
-                    else if ( (LA65_3==62) ) {
-                        alt65=2;
+                    else if ( (LA66_3==EOF) ) {
+                        alt66=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 65, 3, input);
+                            new NoViableAltException("", 66, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 65, 1, input);
+                        new NoViableAltException("", 66, 1, input);
 
                     throw nvae;
                 }
@@ -8794,27 +8919,27 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case 61:
                 {
-                int LA65_2 = input.LA(2);
+                int LA66_2 = input.LA(2);
 
-                if ( (LA65_2==RULE_INT) ) {
-                    int LA65_3 = input.LA(3);
+                if ( (LA66_2==RULE_INT) ) {
+                    int LA66_3 = input.LA(3);
 
-                    if ( (LA65_3==EOF) ) {
-                        alt65=1;
+                    if ( (LA66_3==62) ) {
+                        alt66=2;
                     }
-                    else if ( (LA65_3==62) ) {
-                        alt65=2;
+                    else if ( (LA66_3==EOF) ) {
+                        alt66=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 65, 3, input);
+                            new NoViableAltException("", 66, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 65, 2, input);
+                        new NoViableAltException("", 66, 2, input);
 
                     throw nvae;
                 }
@@ -8822,17 +8947,17 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA65_3 = input.LA(2);
+                int LA66_3 = input.LA(2);
 
-                if ( (LA65_3==EOF) ) {
-                    alt65=1;
+                if ( (LA66_3==62) ) {
+                    alt66=2;
                 }
-                else if ( (LA65_3==62) ) {
-                    alt65=2;
+                else if ( (LA66_3==EOF) ) {
+                    alt66=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 65, 3, input);
+                        new NoViableAltException("", 66, 3, input);
 
                     throw nvae;
                 }
@@ -8840,19 +8965,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_HEX:
                 {
-                alt65=1;
+                alt66=1;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 65, 0, input);
+                    new NoViableAltException("", 66, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt65) {
+            switch (alt66) {
                 case 1 :
-                    // InternalFSM.g:3453:5: this_IntLiteral_0= ruleIntLiteral
+                    // InternalFSM.g:3491:5: this_IntLiteral_0= ruleIntLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
@@ -8870,7 +8995,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3463:5: this_RealLiteral_1= ruleRealLiteral
+                    // InternalFSM.g:3501:5: this_RealLiteral_1= ruleRealLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
@@ -8908,7 +9033,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalFSM.g:3479:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
+    // InternalFSM.g:3517:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
     public final EObject entryRuleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8916,8 +9041,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3480:2: (iv_ruleRealLiteral= ruleRealLiteral EOF )
-            // InternalFSM.g:3481:2: iv_ruleRealLiteral= ruleRealLiteral EOF
+            // InternalFSM.g:3518:2: (iv_ruleRealLiteral= ruleRealLiteral EOF )
+            // InternalFSM.g:3519:2: iv_ruleRealLiteral= ruleRealLiteral EOF
             {
              newCompositeNode(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -8944,7 +9069,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRealLiteral"
-    // InternalFSM.g:3488:1: ruleRealLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleReal ) ) ) ;
+    // InternalFSM.g:3526:1: ruleRealLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleReal ) ) ) ;
     public final EObject ruleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -8954,14 +9079,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3491:28: ( ( () ( (lv_value_1_0= ruleReal ) ) ) )
-            // InternalFSM.g:3492:1: ( () ( (lv_value_1_0= ruleReal ) ) )
+            // InternalFSM.g:3529:28: ( ( () ( (lv_value_1_0= ruleReal ) ) ) )
+            // InternalFSM.g:3530:1: ( () ( (lv_value_1_0= ruleReal ) ) )
             {
-            // InternalFSM.g:3492:1: ( () ( (lv_value_1_0= ruleReal ) ) )
-            // InternalFSM.g:3492:2: () ( (lv_value_1_0= ruleReal ) )
+            // InternalFSM.g:3530:1: ( () ( (lv_value_1_0= ruleReal ) ) )
+            // InternalFSM.g:3530:2: () ( (lv_value_1_0= ruleReal ) )
             {
-            // InternalFSM.g:3492:2: ()
-            // InternalFSM.g:3493:5: 
+            // InternalFSM.g:3530:2: ()
+            // InternalFSM.g:3531:5: 
             {
 
                     current = forceCreateModelElement(
@@ -8971,11 +9096,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3498:2: ( (lv_value_1_0= ruleReal ) )
-            // InternalFSM.g:3499:1: (lv_value_1_0= ruleReal )
+            // InternalFSM.g:3536:2: ( (lv_value_1_0= ruleReal ) )
+            // InternalFSM.g:3537:1: (lv_value_1_0= ruleReal )
             {
-            // InternalFSM.g:3499:1: (lv_value_1_0= ruleReal )
-            // InternalFSM.g:3500:3: lv_value_1_0= ruleReal
+            // InternalFSM.g:3537:1: (lv_value_1_0= ruleReal )
+            // InternalFSM.g:3538:3: lv_value_1_0= ruleReal
             {
              
             	        newCompositeNode(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
@@ -9023,7 +9148,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalFSM.g:3524:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
+    // InternalFSM.g:3562:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
     public final EObject entryRuleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -9031,8 +9156,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3525:2: (iv_ruleIntLiteral= ruleIntLiteral EOF )
-            // InternalFSM.g:3526:2: iv_ruleIntLiteral= ruleIntLiteral EOF
+            // InternalFSM.g:3563:2: (iv_ruleIntLiteral= ruleIntLiteral EOF )
+            // InternalFSM.g:3564:2: iv_ruleIntLiteral= ruleIntLiteral EOF
             {
              newCompositeNode(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -9059,7 +9184,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleIntLiteral"
-    // InternalFSM.g:3533:1: ruleIntLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleInteger ) ) ) ;
+    // InternalFSM.g:3571:1: ruleIntLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleInteger ) ) ) ;
     public final EObject ruleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -9069,14 +9194,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3536:28: ( ( () ( (lv_value_1_0= ruleInteger ) ) ) )
-            // InternalFSM.g:3537:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
+            // InternalFSM.g:3574:28: ( ( () ( (lv_value_1_0= ruleInteger ) ) ) )
+            // InternalFSM.g:3575:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
             {
-            // InternalFSM.g:3537:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
-            // InternalFSM.g:3537:2: () ( (lv_value_1_0= ruleInteger ) )
+            // InternalFSM.g:3575:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
+            // InternalFSM.g:3575:2: () ( (lv_value_1_0= ruleInteger ) )
             {
-            // InternalFSM.g:3537:2: ()
-            // InternalFSM.g:3538:5: 
+            // InternalFSM.g:3575:2: ()
+            // InternalFSM.g:3576:5: 
             {
 
                     current = forceCreateModelElement(
@@ -9086,11 +9211,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3543:2: ( (lv_value_1_0= ruleInteger ) )
-            // InternalFSM.g:3544:1: (lv_value_1_0= ruleInteger )
+            // InternalFSM.g:3581:2: ( (lv_value_1_0= ruleInteger ) )
+            // InternalFSM.g:3582:1: (lv_value_1_0= ruleInteger )
             {
-            // InternalFSM.g:3544:1: (lv_value_1_0= ruleInteger )
-            // InternalFSM.g:3545:3: lv_value_1_0= ruleInteger
+            // InternalFSM.g:3582:1: (lv_value_1_0= ruleInteger )
+            // InternalFSM.g:3583:3: lv_value_1_0= ruleInteger
             {
              
             	        newCompositeNode(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
@@ -9138,7 +9263,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalFSM.g:3569:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
+    // InternalFSM.g:3607:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
     public final EObject entryRuleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -9146,8 +9271,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3570:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
-            // InternalFSM.g:3571:2: iv_ruleStringLiteral= ruleStringLiteral EOF
+            // InternalFSM.g:3608:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
+            // InternalFSM.g:3609:2: iv_ruleStringLiteral= ruleStringLiteral EOF
             {
              newCompositeNode(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -9174,7 +9299,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStringLiteral"
-    // InternalFSM.g:3578:1: ruleStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
+    // InternalFSM.g:3616:1: ruleStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
     public final EObject ruleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -9183,14 +9308,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3581:28: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
-            // InternalFSM.g:3582:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalFSM.g:3619:28: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
+            // InternalFSM.g:3620:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
             {
-            // InternalFSM.g:3582:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
-            // InternalFSM.g:3582:2: () ( (lv_value_1_0= RULE_STRING ) )
+            // InternalFSM.g:3620:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalFSM.g:3620:2: () ( (lv_value_1_0= RULE_STRING ) )
             {
-            // InternalFSM.g:3582:2: ()
-            // InternalFSM.g:3583:5: 
+            // InternalFSM.g:3620:2: ()
+            // InternalFSM.g:3621:5: 
             {
 
                     current = forceCreateModelElement(
@@ -9200,11 +9325,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3588:2: ( (lv_value_1_0= RULE_STRING ) )
-            // InternalFSM.g:3589:1: (lv_value_1_0= RULE_STRING )
+            // InternalFSM.g:3626:2: ( (lv_value_1_0= RULE_STRING ) )
+            // InternalFSM.g:3627:1: (lv_value_1_0= RULE_STRING )
             {
-            // InternalFSM.g:3589:1: (lv_value_1_0= RULE_STRING )
-            // InternalFSM.g:3590:3: lv_value_1_0= RULE_STRING
+            // InternalFSM.g:3627:1: (lv_value_1_0= RULE_STRING )
+            // InternalFSM.g:3628:3: lv_value_1_0= RULE_STRING
             {
             lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
 
@@ -9247,7 +9372,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalFSM.g:3614:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
+    // InternalFSM.g:3652:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
     public final String entryRuleInteger() throws RecognitionException {
         String current = null;
 
@@ -9255,8 +9380,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3615:2: (iv_ruleInteger= ruleInteger EOF )
-            // InternalFSM.g:3616:2: iv_ruleInteger= ruleInteger EOF
+            // InternalFSM.g:3653:2: (iv_ruleInteger= ruleInteger EOF )
+            // InternalFSM.g:3654:2: iv_ruleInteger= ruleInteger EOF
             {
              newCompositeNode(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -9283,7 +9408,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInteger"
-    // InternalFSM.g:3623:1: ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) ;
+    // InternalFSM.g:3661:1: ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) ;
     public final AntlrDatatypeRuleToken ruleInteger() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -9294,45 +9419,45 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3626:28: ( ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) )
-            // InternalFSM.g:3627:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
+            // InternalFSM.g:3664:28: ( ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) )
+            // InternalFSM.g:3665:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
             {
-            // InternalFSM.g:3627:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
-            int alt67=2;
-            int LA67_0 = input.LA(1);
+            // InternalFSM.g:3665:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
+            int alt68=2;
+            int LA68_0 = input.LA(1);
 
-            if ( (LA67_0==RULE_INT||(LA67_0>=60 && LA67_0<=61)) ) {
-                alt67=1;
+            if ( (LA68_0==RULE_INT||(LA68_0>=60 && LA68_0<=61)) ) {
+                alt68=1;
             }
-            else if ( (LA67_0==RULE_HEX) ) {
-                alt67=2;
+            else if ( (LA68_0==RULE_HEX) ) {
+                alt68=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 67, 0, input);
+                    new NoViableAltException("", 68, 0, input);
 
                 throw nvae;
             }
-            switch (alt67) {
+            switch (alt68) {
                 case 1 :
-                    // InternalFSM.g:3627:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalFSM.g:3665:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
                     {
-                    // InternalFSM.g:3627:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
-                    // InternalFSM.g:3627:3: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT
+                    // InternalFSM.g:3665:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalFSM.g:3665:3: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT
                     {
-                    // InternalFSM.g:3627:3: (kw= '+' | kw= '-' )?
-                    int alt66=3;
-                    int LA66_0 = input.LA(1);
+                    // InternalFSM.g:3665:3: (kw= '+' | kw= '-' )?
+                    int alt67=3;
+                    int LA67_0 = input.LA(1);
 
-                    if ( (LA66_0==60) ) {
-                        alt66=1;
+                    if ( (LA67_0==60) ) {
+                        alt67=1;
                     }
-                    else if ( (LA66_0==61) ) {
-                        alt66=2;
+                    else if ( (LA67_0==61) ) {
+                        alt67=2;
                     }
-                    switch (alt66) {
+                    switch (alt67) {
                         case 1 :
-                            // InternalFSM.g:3628:2: kw= '+'
+                            // InternalFSM.g:3666:2: kw= '+'
                             {
                             kw=(Token)match(input,60,FOLLOW_54); 
 
@@ -9343,7 +9468,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalFSM.g:3635:2: kw= '-'
+                            // InternalFSM.g:3673:2: kw= '-'
                             {
                             kw=(Token)match(input,61,FOLLOW_54); 
 
@@ -9370,7 +9495,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3648:10: this_HEX_3= RULE_HEX
+                    // InternalFSM.g:3686:10: this_HEX_3= RULE_HEX
                     {
                     this_HEX_3=(Token)match(input,RULE_HEX,FOLLOW_2); 
 
@@ -9403,7 +9528,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalFSM.g:3663:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
+    // InternalFSM.g:3701:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
     public final String entryRuleReal() throws RecognitionException {
         String current = null;
 
@@ -9411,8 +9536,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3664:2: (iv_ruleReal= ruleReal EOF )
-            // InternalFSM.g:3665:2: iv_ruleReal= ruleReal EOF
+            // InternalFSM.g:3702:2: (iv_ruleReal= ruleReal EOF )
+            // InternalFSM.g:3703:2: iv_ruleReal= ruleReal EOF
             {
              newCompositeNode(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -9439,7 +9564,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleReal"
-    // InternalFSM.g:3672:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) ;
+    // InternalFSM.g:3710:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) ;
     public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -9451,55 +9576,55 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3675:28: ( (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) )
-            // InternalFSM.g:3676:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
+            // InternalFSM.g:3713:28: ( (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) )
+            // InternalFSM.g:3714:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
             {
-            // InternalFSM.g:3676:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
-            int alt68=2;
+            // InternalFSM.g:3714:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
+            int alt69=2;
             switch ( input.LA(1) ) {
             case 60:
                 {
-                int LA68_1 = input.LA(2);
+                int LA69_1 = input.LA(2);
 
-                if ( (LA68_1==RULE_INT) ) {
-                    int LA68_3 = input.LA(3);
+                if ( (LA69_1==RULE_INT) ) {
+                    int LA69_3 = input.LA(3);
 
-                    if ( (LA68_3==62) ) {
-                        int LA68_4 = input.LA(4);
+                    if ( (LA69_3==62) ) {
+                        int LA69_4 = input.LA(4);
 
-                        if ( (LA68_4==RULE_INT) ) {
-                            int LA68_5 = input.LA(5);
+                        if ( (LA69_4==RULE_INT) ) {
+                            int LA69_5 = input.LA(5);
 
-                            if ( (LA68_5==EOF) ) {
-                                alt68=1;
+                            if ( (LA69_5==EOF) ) {
+                                alt69=1;
                             }
-                            else if ( ((LA68_5>=63 && LA68_5<=64)) ) {
-                                alt68=2;
+                            else if ( ((LA69_5>=63 && LA69_5<=64)) ) {
+                                alt69=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 68, 5, input);
+                                    new NoViableAltException("", 69, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 68, 4, input);
+                                new NoViableAltException("", 69, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 68, 3, input);
+                            new NoViableAltException("", 69, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 68, 1, input);
+                        new NoViableAltException("", 69, 1, input);
 
                     throw nvae;
                 }
@@ -9507,47 +9632,47 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case 61:
                 {
-                int LA68_2 = input.LA(2);
+                int LA69_2 = input.LA(2);
 
-                if ( (LA68_2==RULE_INT) ) {
-                    int LA68_3 = input.LA(3);
+                if ( (LA69_2==RULE_INT) ) {
+                    int LA69_3 = input.LA(3);
 
-                    if ( (LA68_3==62) ) {
-                        int LA68_4 = input.LA(4);
+                    if ( (LA69_3==62) ) {
+                        int LA69_4 = input.LA(4);
 
-                        if ( (LA68_4==RULE_INT) ) {
-                            int LA68_5 = input.LA(5);
+                        if ( (LA69_4==RULE_INT) ) {
+                            int LA69_5 = input.LA(5);
 
-                            if ( (LA68_5==EOF) ) {
-                                alt68=1;
+                            if ( (LA69_5==EOF) ) {
+                                alt69=1;
                             }
-                            else if ( ((LA68_5>=63 && LA68_5<=64)) ) {
-                                alt68=2;
+                            else if ( ((LA69_5>=63 && LA69_5<=64)) ) {
+                                alt69=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 68, 5, input);
+                                    new NoViableAltException("", 69, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 68, 4, input);
+                                new NoViableAltException("", 69, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 68, 3, input);
+                            new NoViableAltException("", 69, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 68, 2, input);
+                        new NoViableAltException("", 69, 2, input);
 
                     throw nvae;
                 }
@@ -9555,37 +9680,37 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA68_3 = input.LA(2);
+                int LA69_3 = input.LA(2);
 
-                if ( (LA68_3==62) ) {
-                    int LA68_4 = input.LA(3);
+                if ( (LA69_3==62) ) {
+                    int LA69_4 = input.LA(3);
 
-                    if ( (LA68_4==RULE_INT) ) {
-                        int LA68_5 = input.LA(4);
+                    if ( (LA69_4==RULE_INT) ) {
+                        int LA69_5 = input.LA(4);
 
-                        if ( (LA68_5==EOF) ) {
-                            alt68=1;
+                        if ( (LA69_5==EOF) ) {
+                            alt69=1;
                         }
-                        else if ( ((LA68_5>=63 && LA68_5<=64)) ) {
-                            alt68=2;
+                        else if ( ((LA69_5>=63 && LA69_5<=64)) ) {
+                            alt69=2;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 68, 5, input);
+                                new NoViableAltException("", 69, 5, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 68, 4, input);
+                            new NoViableAltException("", 69, 4, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 68, 3, input);
+                        new NoViableAltException("", 69, 3, input);
 
                     throw nvae;
                 }
@@ -9593,14 +9718,14 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 68, 0, input);
+                    new NoViableAltException("", 69, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt68) {
+            switch (alt69) {
                 case 1 :
-                    // InternalFSM.g:3677:5: this_Decimal_0= ruleDecimal
+                    // InternalFSM.g:3715:5: this_Decimal_0= ruleDecimal
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
@@ -9620,7 +9745,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3689:5: this_DecimalExp_1= ruleDecimalExp
+                    // InternalFSM.g:3727:5: this_DecimalExp_1= ruleDecimalExp
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
@@ -9660,7 +9785,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalFSM.g:3707:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
+    // InternalFSM.g:3745:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
     public final String entryRuleDecimal() throws RecognitionException {
         String current = null;
 
@@ -9671,8 +9796,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         	
         try {
-            // InternalFSM.g:3711:2: (iv_ruleDecimal= ruleDecimal EOF )
-            // InternalFSM.g:3712:2: iv_ruleDecimal= ruleDecimal EOF
+            // InternalFSM.g:3749:2: (iv_ruleDecimal= ruleDecimal EOF )
+            // InternalFSM.g:3750:2: iv_ruleDecimal= ruleDecimal EOF
             {
              newCompositeNode(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -9702,7 +9827,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDecimal"
-    // InternalFSM.g:3722:1: ruleDecimal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) ;
+    // InternalFSM.g:3760:1: ruleDecimal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) ;
     public final AntlrDatatypeRuleToken ruleDecimal() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -9714,25 +9839,25 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
             
         try {
-            // InternalFSM.g:3726:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) )
-            // InternalFSM.g:3727:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
+            // InternalFSM.g:3764:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) )
+            // InternalFSM.g:3765:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
             {
-            // InternalFSM.g:3727:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
-            // InternalFSM.g:3727:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT
+            // InternalFSM.g:3765:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
+            // InternalFSM.g:3765:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT
             {
-            // InternalFSM.g:3727:2: (kw= '+' | kw= '-' )?
-            int alt69=3;
-            int LA69_0 = input.LA(1);
+            // InternalFSM.g:3765:2: (kw= '+' | kw= '-' )?
+            int alt70=3;
+            int LA70_0 = input.LA(1);
 
-            if ( (LA69_0==60) ) {
-                alt69=1;
+            if ( (LA70_0==60) ) {
+                alt70=1;
             }
-            else if ( (LA69_0==61) ) {
-                alt69=2;
+            else if ( (LA70_0==61) ) {
+                alt70=2;
             }
-            switch (alt69) {
+            switch (alt70) {
                 case 1 :
-                    // InternalFSM.g:3728:2: kw= '+'
+                    // InternalFSM.g:3766:2: kw= '+'
                     {
                     kw=(Token)match(input,60,FOLLOW_54); 
 
@@ -9743,7 +9868,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3735:2: kw= '-'
+                    // InternalFSM.g:3773:2: kw= '-'
                     {
                     kw=(Token)match(input,61,FOLLOW_54); 
 
@@ -9799,7 +9924,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalFSM.g:3771:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
+    // InternalFSM.g:3809:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
     public final String entryRuleDecimalExp() throws RecognitionException {
         String current = null;
 
@@ -9810,8 +9935,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         	
         try {
-            // InternalFSM.g:3775:2: (iv_ruleDecimalExp= ruleDecimalExp EOF )
-            // InternalFSM.g:3776:2: iv_ruleDecimalExp= ruleDecimalExp EOF
+            // InternalFSM.g:3813:2: (iv_ruleDecimalExp= ruleDecimalExp EOF )
+            // InternalFSM.g:3814:2: iv_ruleDecimalExp= ruleDecimalExp EOF
             {
              newCompositeNode(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -9841,7 +9966,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDecimalExp"
-    // InternalFSM.g:3786:1: ruleDecimalExp returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) ;
+    // InternalFSM.g:3824:1: ruleDecimalExp returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) ;
     public final AntlrDatatypeRuleToken ruleDecimalExp() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -9854,25 +9979,25 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
             
         try {
-            // InternalFSM.g:3790:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) )
-            // InternalFSM.g:3791:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
+            // InternalFSM.g:3828:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) )
+            // InternalFSM.g:3829:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
             {
-            // InternalFSM.g:3791:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
-            // InternalFSM.g:3791:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT
+            // InternalFSM.g:3829:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
+            // InternalFSM.g:3829:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT
             {
-            // InternalFSM.g:3791:2: (kw= '+' | kw= '-' )?
-            int alt70=3;
-            int LA70_0 = input.LA(1);
+            // InternalFSM.g:3829:2: (kw= '+' | kw= '-' )?
+            int alt71=3;
+            int LA71_0 = input.LA(1);
 
-            if ( (LA70_0==60) ) {
-                alt70=1;
+            if ( (LA71_0==60) ) {
+                alt71=1;
             }
-            else if ( (LA70_0==61) ) {
-                alt70=2;
+            else if ( (LA71_0==61) ) {
+                alt71=2;
             }
-            switch (alt70) {
+            switch (alt71) {
                 case 1 :
-                    // InternalFSM.g:3792:2: kw= '+'
+                    // InternalFSM.g:3830:2: kw= '+'
                     {
                     kw=(Token)match(input,60,FOLLOW_54); 
 
@@ -9883,7 +10008,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3799:2: kw= '-'
+                    // InternalFSM.g:3837:2: kw= '-'
                     {
                     kw=(Token)match(input,61,FOLLOW_54); 
 
@@ -9915,25 +10040,25 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
              
                 newLeafNode(this_INT_4, grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); 
                 
-            // InternalFSM.g:3824:1: (kw= 'e' | kw= 'E' )
-            int alt71=2;
-            int LA71_0 = input.LA(1);
+            // InternalFSM.g:3862:1: (kw= 'e' | kw= 'E' )
+            int alt72=2;
+            int LA72_0 = input.LA(1);
 
-            if ( (LA71_0==63) ) {
-                alt71=1;
+            if ( (LA72_0==63) ) {
+                alt72=1;
             }
-            else if ( (LA71_0==64) ) {
-                alt71=2;
+            else if ( (LA72_0==64) ) {
+                alt72=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 71, 0, input);
+                    new NoViableAltException("", 72, 0, input);
 
                 throw nvae;
             }
-            switch (alt71) {
+            switch (alt72) {
                 case 1 :
-                    // InternalFSM.g:3825:2: kw= 'e'
+                    // InternalFSM.g:3863:2: kw= 'e'
                     {
                     kw=(Token)match(input,63,FOLLOW_57); 
 
@@ -9944,7 +10069,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3832:2: kw= 'E'
+                    // InternalFSM.g:3870:2: kw= 'E'
                     {
                     kw=(Token)match(input,64,FOLLOW_57); 
 
@@ -9957,19 +10082,19 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalFSM.g:3837:2: (kw= '+' | kw= '-' )?
-            int alt72=3;
-            int LA72_0 = input.LA(1);
+            // InternalFSM.g:3875:2: (kw= '+' | kw= '-' )?
+            int alt73=3;
+            int LA73_0 = input.LA(1);
 
-            if ( (LA72_0==60) ) {
-                alt72=1;
+            if ( (LA73_0==60) ) {
+                alt73=1;
             }
-            else if ( (LA72_0==61) ) {
-                alt72=2;
+            else if ( (LA73_0==61) ) {
+                alt73=2;
             }
-            switch (alt72) {
+            switch (alt73) {
                 case 1 :
-                    // InternalFSM.g:3838:2: kw= '+'
+                    // InternalFSM.g:3876:2: kw= '+'
                     {
                     kw=(Token)match(input,60,FOLLOW_54); 
 
@@ -9980,7 +10105,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3845:2: kw= '-'
+                    // InternalFSM.g:3883:2: kw= '-'
                     {
                     kw=(Token)match(input,61,FOLLOW_54); 
 
@@ -10024,7 +10149,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalFSM.g:3868:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
+    // InternalFSM.g:3906:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
     public final String entryRuleFQN() throws RecognitionException {
         String current = null;
 
@@ -10032,8 +10157,8 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalFSM.g:3869:2: (iv_ruleFQN= ruleFQN EOF )
-            // InternalFSM.g:3870:2: iv_ruleFQN= ruleFQN EOF
+            // InternalFSM.g:3907:2: (iv_ruleFQN= ruleFQN EOF )
+            // InternalFSM.g:3908:2: iv_ruleFQN= ruleFQN EOF
             {
              newCompositeNode(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -10060,7 +10185,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleFQN"
-    // InternalFSM.g:3877:1: ruleFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) ;
+    // InternalFSM.g:3915:1: ruleFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) ;
     public final AntlrDatatypeRuleToken ruleFQN() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -10071,11 +10196,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalFSM.g:3880:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
-            // InternalFSM.g:3881:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
+            // InternalFSM.g:3918:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
+            // InternalFSM.g:3919:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
             {
-            // InternalFSM.g:3881:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
-            // InternalFSM.g:3881:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
+            // InternalFSM.g:3919:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
+            // InternalFSM.g:3919:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
             {
             this_ID_0=(Token)match(input,RULE_ID,FOLLOW_58); 
 
@@ -10084,20 +10209,20 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
              
                 newLeafNode(this_ID_0, grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
                 
-            // InternalFSM.g:3888:1: (kw= '.' this_ID_2= RULE_ID )*
-            loop73:
+            // InternalFSM.g:3926:1: (kw= '.' this_ID_2= RULE_ID )*
+            loop74:
             do {
-                int alt73=2;
-                int LA73_0 = input.LA(1);
+                int alt74=2;
+                int LA74_0 = input.LA(1);
 
-                if ( (LA73_0==62) ) {
-                    alt73=1;
+                if ( (LA74_0==62) ) {
+                    alt74=1;
                 }
 
 
-                switch (alt73) {
+                switch (alt74) {
             	case 1 :
-            	    // InternalFSM.g:3889:2: kw= '.' this_ID_2= RULE_ID
+            	    // InternalFSM.g:3927:2: kw= '.' this_ID_2= RULE_ID
             	    {
             	    kw=(Token)match(input,62,FOLLOW_5); 
 
@@ -10116,7 +10241,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop73;
+            	    break loop74;
                 }
             } while (true);
 
@@ -10141,7 +10266,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleComponentCommunicationType"
-    // InternalFSM.g:3909:1: ruleComponentCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) ;
+    // InternalFSM.g:3947:1: ruleComponentCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) ;
     public final Enumerator ruleComponentCommunicationType() throws RecognitionException {
         Enumerator current = null;
 
@@ -10152,45 +10277,45 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalFSM.g:3911:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) )
-            // InternalFSM.g:3912:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
+            // InternalFSM.g:3949:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) )
+            // InternalFSM.g:3950:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
             {
-            // InternalFSM.g:3912:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
-            int alt74=4;
+            // InternalFSM.g:3950:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
+            int alt75=4;
             switch ( input.LA(1) ) {
             case 65:
                 {
-                alt74=1;
+                alt75=1;
                 }
                 break;
             case 66:
                 {
-                alt74=2;
+                alt75=2;
                 }
                 break;
             case 67:
                 {
-                alt74=3;
+                alt75=3;
                 }
                 break;
             case 68:
                 {
-                alt74=4;
+                alt75=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 74, 0, input);
+                    new NoViableAltException("", 75, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt74) {
+            switch (alt75) {
                 case 1 :
-                    // InternalFSM.g:3912:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalFSM.g:3950:2: (enumLiteral_0= 'eventdriven' )
                     {
-                    // InternalFSM.g:3912:2: (enumLiteral_0= 'eventdriven' )
-                    // InternalFSM.g:3912:4: enumLiteral_0= 'eventdriven'
+                    // InternalFSM.g:3950:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalFSM.g:3950:4: enumLiteral_0= 'eventdriven'
                     {
                     enumLiteral_0=(Token)match(input,65,FOLLOW_2); 
 
@@ -10204,10 +10329,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3918:6: (enumLiteral_1= 'datadriven' )
+                    // InternalFSM.g:3956:6: (enumLiteral_1= 'datadriven' )
                     {
-                    // InternalFSM.g:3918:6: (enumLiteral_1= 'datadriven' )
-                    // InternalFSM.g:3918:8: enumLiteral_1= 'datadriven'
+                    // InternalFSM.g:3956:6: (enumLiteral_1= 'datadriven' )
+                    // InternalFSM.g:3956:8: enumLiteral_1= 'datadriven'
                     {
                     enumLiteral_1=(Token)match(input,66,FOLLOW_2); 
 
@@ -10221,10 +10346,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:3924:6: (enumLiteral_2= 'async' )
+                    // InternalFSM.g:3962:6: (enumLiteral_2= 'async' )
                     {
-                    // InternalFSM.g:3924:6: (enumLiteral_2= 'async' )
-                    // InternalFSM.g:3924:8: enumLiteral_2= 'async'
+                    // InternalFSM.g:3962:6: (enumLiteral_2= 'async' )
+                    // InternalFSM.g:3962:8: enumLiteral_2= 'async'
                     {
                     enumLiteral_2=(Token)match(input,67,FOLLOW_2); 
 
@@ -10238,10 +10363,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:3930:6: (enumLiteral_3= 'sync' )
+                    // InternalFSM.g:3968:6: (enumLiteral_3= 'sync' )
                     {
-                    // InternalFSM.g:3930:6: (enumLiteral_3= 'sync' )
-                    // InternalFSM.g:3930:8: enumLiteral_3= 'sync'
+                    // InternalFSM.g:3968:6: (enumLiteral_3= 'sync' )
+                    // InternalFSM.g:3968:8: enumLiteral_3= 'sync'
                     {
                     enumLiteral_3=(Token)match(input,68,FOLLOW_2); 
 
@@ -10275,7 +10400,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLiteralType"
-    // InternalFSM.g:3940:1: ruleLiteralType returns [Enumerator current=null] : ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) ;
+    // InternalFSM.g:3978:1: ruleLiteralType returns [Enumerator current=null] : ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) ;
     public final Enumerator ruleLiteralType() throws RecognitionException {
         Enumerator current = null;
 
@@ -10286,45 +10411,45 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalFSM.g:3942:28: ( ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) )
-            // InternalFSM.g:3943:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
+            // InternalFSM.g:3980:28: ( ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) )
+            // InternalFSM.g:3981:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
             {
-            // InternalFSM.g:3943:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
-            int alt75=4;
+            // InternalFSM.g:3981:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
+            int alt76=4;
             switch ( input.LA(1) ) {
             case 69:
                 {
-                alt75=1;
+                alt76=1;
                 }
                 break;
             case 70:
                 {
-                alt75=2;
+                alt76=2;
                 }
                 break;
             case 71:
                 {
-                alt75=3;
+                alt76=3;
                 }
                 break;
             case 72:
                 {
-                alt75=4;
+                alt76=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 75, 0, input);
+                    new NoViableAltException("", 76, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt75) {
+            switch (alt76) {
                 case 1 :
-                    // InternalFSM.g:3943:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalFSM.g:3981:2: (enumLiteral_0= 'ptBoolean' )
                     {
-                    // InternalFSM.g:3943:2: (enumLiteral_0= 'ptBoolean' )
-                    // InternalFSM.g:3943:4: enumLiteral_0= 'ptBoolean'
+                    // InternalFSM.g:3981:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalFSM.g:3981:4: enumLiteral_0= 'ptBoolean'
                     {
                     enumLiteral_0=(Token)match(input,69,FOLLOW_2); 
 
@@ -10338,10 +10463,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalFSM.g:3949:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalFSM.g:3987:6: (enumLiteral_1= 'ptInteger' )
                     {
-                    // InternalFSM.g:3949:6: (enumLiteral_1= 'ptInteger' )
-                    // InternalFSM.g:3949:8: enumLiteral_1= 'ptInteger'
+                    // InternalFSM.g:3987:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalFSM.g:3987:8: enumLiteral_1= 'ptInteger'
                     {
                     enumLiteral_1=(Token)match(input,70,FOLLOW_2); 
 
@@ -10355,10 +10480,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalFSM.g:3955:6: (enumLiteral_2= 'ptReal' )
+                    // InternalFSM.g:3993:6: (enumLiteral_2= 'ptReal' )
                     {
-                    // InternalFSM.g:3955:6: (enumLiteral_2= 'ptReal' )
-                    // InternalFSM.g:3955:8: enumLiteral_2= 'ptReal'
+                    // InternalFSM.g:3993:6: (enumLiteral_2= 'ptReal' )
+                    // InternalFSM.g:3993:8: enumLiteral_2= 'ptReal'
                     {
                     enumLiteral_2=(Token)match(input,71,FOLLOW_2); 
 
@@ -10372,10 +10497,10 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalFSM.g:3961:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalFSM.g:3999:6: (enumLiteral_3= 'ptCharacter' )
                     {
-                    // InternalFSM.g:3961:6: (enumLiteral_3= 'ptCharacter' )
-                    // InternalFSM.g:3961:8: enumLiteral_3= 'ptCharacter'
+                    // InternalFSM.g:3999:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalFSM.g:3999:8: enumLiteral_3= 'ptCharacter'
                     {
                     enumLiteral_3=(Token)match(input,72,FOLLOW_2); 
 
@@ -10410,12 +10535,12 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
     // Delegated rules
 
 
-    protected DFA26 dfa26 = new DFA26(this);
     protected DFA27 dfa27 = new DFA27(this);
+    protected DFA28 dfa28 = new DFA28(this);
     static final String dfa_1s = "\32\uffff";
-    static final String dfa_2s = "\13\uffff\1\22\7\uffff\3\22\1\uffff\1\22\2\uffff";
-    static final String dfa_3s = "\1\36\1\4\1\37\1\4\1\41\4\4\2\41\1\20\2\4\1\41\1\4\1\6\1\21\1\uffff\3\20\1\6\1\20\2\uffff";
-    static final String dfa_4s = "\1\36\2\37\1\52\1\51\2\4\1\52\1\4\2\41\1\70\2\4\1\41\1\4\1\71\1\46\1\uffff\3\70\1\71\1\47\2\uffff";
+    static final String dfa_2s = "\14\uffff\1\22\6\uffff\3\22\1\uffff\1\22\2\uffff";
+    static final String dfa_3s = "\1\36\1\4\1\37\1\4\1\41\4\4\3\41\1\20\3\4\1\6\1\21\1\uffff\3\20\1\6\1\20\2\uffff";
+    static final String dfa_4s = "\1\36\2\37\1\52\1\51\3\4\1\52\3\41\1\70\3\4\1\71\1\46\1\uffff\3\70\1\71\1\47\2\uffff";
     static final String dfa_5s = "\22\uffff\1\2\5\uffff\1\1\1\3";
     static final String dfa_6s = "\32\uffff}>";
     static final String[] dfa_7s = {
@@ -10423,17 +10548,17 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             "\1\2\32\uffff\1\3",
             "\1\3",
             "\1\4\43\uffff\1\5\1\uffff\1\6",
-            "\1\7\7\uffff\1\10",
+            "\1\10\7\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\43\uffff\1\14\1\uffff\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
+            "\1\13",
+            "\1\14\43\uffff\1\15\1\uffff\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
             "\1\21\1\22\1\uffff\1\22\4\uffff\7\22\10\uffff\1\22\1\uffff\1\17\16\uffff\1\20",
             "\1\23",
             "\1\24",
-            "\1\7",
             "\1\25",
             "\1\26\62\uffff\1\27",
             "\1\22\20\uffff\1\22\1\30\1\uffff\1\30\1\31",
@@ -10455,11 +10580,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
     static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
     static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
 
-    class DFA26 extends DFA {
+    class DFA27 extends DFA {
 
-        public DFA26(BaseRecognizer recognizer) {
+        public DFA27(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 26;
+            this.decisionNumber = 27;
             this.eot = dfa_1;
             this.eof = dfa_2;
             this.min = dfa_3;
@@ -10469,13 +10594,13 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             this.transition = dfa_7;
         }
         public String getDescription() {
-            return "1318:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )";
+            return "1356:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )";
         }
     }
     static final String dfa_8s = "\31\uffff";
-    static final String dfa_9s = "\1\36\1\4\1\37\1\4\1\41\4\4\2\41\1\20\2\4\1\41\1\6\1\43\1\4\2\20\1\6\1\20\2\uffff\1\20";
-    static final String dfa_10s = "\1\36\2\37\1\52\1\51\2\4\1\52\1\4\2\41\1\70\2\4\1\41\1\71\1\45\1\4\2\70\1\71\1\20\2\uffff\1\70";
-    static final String dfa_11s = "\26\uffff\1\1\1\2\1\uffff";
+    static final String dfa_9s = "\1\36\1\4\1\37\1\4\1\41\4\4\2\41\1\20\2\4\1\41\1\4\1\6\1\43\3\20\1\6\1\20\2\uffff";
+    static final String dfa_10s = "\1\36\2\37\1\52\1\51\2\4\1\52\1\4\2\41\1\70\2\4\1\41\1\4\1\71\1\45\3\70\1\71\1\20\2\uffff";
+    static final String dfa_11s = "\27\uffff\1\1\1\2";
     static final String dfa_12s = "\31\uffff}>";
     static final String[] dfa_13s = {
             "\1\1",
@@ -10489,20 +10614,20 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             "\1\16",
             "\1\7",
             "\1\7",
-            "\1\20\30\uffff\1\21\16\uffff\1\17",
+            "\1\21\30\uffff\1\17\16\uffff\1\20",
             "\1\22",
             "\1\23",
             "\1\7",
-            "\1\24\62\uffff\1\25",
-            "\1\26\1\uffff\1\27",
-            "\1\30",
-            "\1\20\47\uffff\1\17",
-            "\1\20\47\uffff\1\17",
-            "\1\24\62\uffff\1\25",
-            "\1\20",
-            "",
+            "\1\24",
+            "\1\25\62\uffff\1\26",
+            "\1\27\1\uffff\1\30",
+            "\1\21\47\uffff\1\20",
+            "\1\21\47\uffff\1\20",
+            "\1\21\47\uffff\1\20",
+            "\1\25\62\uffff\1\26",
+            "\1\21",
             "",
-            "\1\20\47\uffff\1\17"
+            ""
     };
 
     static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
@@ -10512,11 +10637,11 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
     static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
     static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
 
-    class DFA27 extends DFA {
+    class DFA28 extends DFA {
 
-        public DFA27(BaseRecognizer recognizer) {
+        public DFA28(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 27;
+            this.decisionNumber = 28;
             this.eot = dfa_8;
             this.eof = dfa_8;
             this.min = dfa_9;
@@ -10526,7 +10651,7 @@ public class InternalFSMParser extends AbstractInternalAntlrParser {
             this.transition = dfa_13;
         }
         public String getDescription() {
-            return "1368:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )";
+            return "1406:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )";
         }
     }
  
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/serializer/FSMSemanticSequencer.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/serializer/FSMSemanticSequencer.java
index 5642345dc..6e45783d4 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/serializer/FSMSemanticSequencer.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/serializer/FSMSemanticSequencer.java
@@ -511,6 +511,7 @@ public class FSMSemanticSequencer extends BaseSemanticSequencer {
 	
 	/**
 	 * Contexts:
+	 *     StateGraphItem returns RefinedTransition
 	 *     TransitionBase returns RefinedTransition
 	 *     RefinedTransition returns RefinedTransition
 	 *
diff --git a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/services/FSMGrammarAccess.java b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/services/FSMGrammarAccess.java
index 028017b5e..8c8b034f7 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/services/FSMGrammarAccess.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src-gen/org/eclipse/etrice/core/fsm/services/FSMGrammarAccess.java
@@ -142,20 +142,20 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.etrice.core.fsm.FSM.StateGraphItem");
 		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
 		private final RuleCall cStateGraphNodeParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
-		private final RuleCall cTransitionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+		private final RuleCall cTransitionBaseParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
 		//StateGraphItem:
-		//	StateGraphNode | Transition;
+		//	StateGraphNode | TransitionBase;
 		@Override public ParserRule getRule() { return rule; }
 
-		//StateGraphNode | Transition
+		//StateGraphNode | TransitionBase
 		public Alternatives getAlternatives() { return cAlternatives; }
 
 		//StateGraphNode
 		public RuleCall getStateGraphNodeParserRuleCall_0() { return cStateGraphNodeParserRuleCall_0; }
 
-		//Transition
-		public RuleCall getTransitionParserRuleCall_1() { return cTransitionParserRuleCall_1; }
+		//TransitionBase
+		public RuleCall getTransitionBaseParserRuleCall_1() { return cTransitionBaseParserRuleCall_1; }
 	}
 
 	public class StateGraphElements extends AbstractParserRuleElementFinder {
@@ -2106,7 +2106,7 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//StateGraphItem:
-	//	StateGraphNode | Transition;
+	//	StateGraphNode | TransitionBase;
 	public StateGraphItemElements getStateGraphItemAccess() {
 		return pStateGraphItem;
 	}
@@ -2497,8 +2497,8 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// **************************************************************
-	// // AnnotationType and Annotation Rules
-	// Annotation:
+	//// AnnotationType and Annotation Rules
+	//Annotation:
 	//	'@' type=[AnnotationType|FQN] ('(' attributes+=KeyValue (',' attributes+=KeyValue)* ')')?;
 	public BaseGrammarAccess.AnnotationElements getAnnotationAccess() {
 		return gaBase.getAnnotationAccess();
@@ -2519,8 +2519,10 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//AnnotationType:
-	//	'AnnotationType' name=ID docu=Documentation? '{' 'target' '=' (targets+=AnnotationTargetType | '{'
-	//	targets+=AnnotationTargetType (',' targets+=AnnotationTargetType)* '}') attributes+=AnnotationAttribute* '}';
+	//	'AnnotationType' name=ID docu=Documentation? '{'
+	//	'target' '=' (targets+=AnnotationTargetType | '{' targets+=AnnotationTargetType (',' targets+=AnnotationTargetType)*
+	//	'}') attributes+=AnnotationAttribute*
+	//	'}';
 	public BaseGrammarAccess.AnnotationTypeElements getAnnotationTypeAccess() {
 		return gaBase.getAnnotationTypeAccess();
 	}
@@ -2530,18 +2532,13 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	// // Sub-grammars should use AnnotationTargetType to refer to 
-	//
+	//// Sub-grammars should use AnnotationTargetType to refer to 
 	//// specific sub-grammar targets. For example, valid values for 
-	//
 	//// AnnotationTargetType in the Room.xtext sub-grammar include "ActorClass", 
-	//
 	//// "ActorBehavior", "ProtocolClass", etc. The sub-grammar is responsible for 
-	//
 	//// implementing validation, quick-fixes, and code completion proposals via the 
-	// // usual Xtext mechanisms.
-	// //
-	//
+	//// usual Xtext mechanisms.
+	////
 	//AnnotationTargetType:
 	//	ID;
 	public BaseGrammarAccess.AnnotationTargetTypeElements getAnnotationTargetTypeAccess() {
@@ -2583,37 +2580,26 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// **************************************************************
-	// // Import rules
-	//
+	//// Import rules
 	//// HOWTO: use a combination of URI global scopes and namespace aware local scope provider
-	//
 	//// this is configured in the work flow by
-	// //			fragment = scoping.ImportURIScopingFragment {}
-	//
+	////			fragment = scoping.ImportURIScopingFragment {}
 	//// and by overriding configureIScopeProviderDelegate in the runtime module with 
-	//
 	////			ImportedNamespaceAwareLocalScopeProvider
-	// // also configure in the RuntimeModule
-	//
+	//// also configure in the RuntimeModule
 	////	public Class<? extends ImportUriResolver> bindImportUriResolver() {
-	// //		return PlatformRelativeUriResolver.class;
-	//
+	////		return PlatformRelativeUriResolver.class;
 	////	}
-	// // and in the UiRuntimeModule
-	//
+	//// and in the UiRuntimeModule
 	////	public Class<? extends org.eclipse.xtext.ui.editor.IURIEditorOpener> bindIURIEditorOpener() {
-	//
 	////		return GlobalNonPlatformURIEditorOpener.class;
-	// //	}
-	//
+	////	}
 	////	public Class<? extends IHyperlinkHelper> bindIHyperlinkHelper() {
-	// //		return ImportAwareHyperlinkHelper.class;
-	//
+	////		return ImportAwareHyperlinkHelper.class;
 	////	}
-	// // the attribute 'importedNamespace' is picked up by the ImportedNamespaceAwareLocalScopeProvider
-	//
+	//// the attribute 'importedNamespace' is picked up by the ImportedNamespaceAwareLocalScopeProvider
 	//// the attribute 'importURI' is picked up by the ImportUriGlobalScopeProvider
-	// Import:
+	//Import:
 	//	'import' (importedNamespace=ImportedFQN 'from' | 'model') importURI=STRING;
 	public BaseGrammarAccess.ImportElements getImportAccess() {
 		return gaBase.getImportAccess();
@@ -2634,9 +2620,12 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// **************************************************************
-	// // Documentation Rule
-	// Documentation:
-	//	{Documentation} '[' lines+=STRING* ']';
+	//// Documentation Rule
+	//Documentation:
+	//	{Documentation}
+	//	'['
+	//	lines+=STRING*
+	//	']';
 	public BaseGrammarAccess.DocumentationElements getDocumentationAccess() {
 		return gaBase.getDocumentationAccess();
 	}
@@ -2646,8 +2635,8 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// **************************************************************
-	// // Time Rule
-	// TIME ecore::ELong:
+	//// Time Rule
+	//TIME ecore::ELong:
 	//	INT 's' | INT 'ms' | INT 'us' | INT 'ns'
 	public BaseGrammarAccess.TIMEElements getTIMEAccess() {
 		return gaBase.getTIMEAccess();
@@ -2658,7 +2647,10 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//enum LiteralType:
-	//	BOOL='ptBoolean' | INT='ptInteger' | REAL='ptReal' | CHAR='ptCharacter';
+	//	BOOL='ptBoolean' |
+	//	INT='ptInteger' |
+	//	REAL='ptReal' |
+	//	CHAR='ptCharacter';
 	public BaseGrammarAccess.LiteralTypeElements getLiteralTypeAccess() {
 		return gaBase.getLiteralTypeAccess();
 	}
@@ -2678,7 +2670,7 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// Value Types for Attributes
-	// Literal:
+	//Literal:
 	//	BooleanLiteral | NumberLiteral | StringLiteral;
 	public BaseGrammarAccess.LiteralElements getLiteralAccess() {
 		return gaBase.getLiteralAccess();
@@ -2769,12 +2761,11 @@ public class FSMGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////DotDecimal hidden():
-	// //	('+' | '-')? '.' INT;
-	// //
-	// //DecimalDot hidden():
-	// //	('+' | '-')? INT '.';
-	// DecimalExp
-	//hidden():
+	////	('+' | '-')? '.' INT;
+	////
+	////DecimalDot hidden():
+	////	('+' | '-')? INT '.';
+	//DecimalExp hidden():
 	//	('+' | '-')? INT '.' INT ('e' | 'E') ('+' | '-')? INT;
 	public BaseGrammarAccess.DecimalExpElements getDecimalExpAccess() {
 		return gaBase.getDecimalExpAccess();
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/FSM.xtext b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/FSM.xtext
index 017051c65..2281e1bf1 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/FSM.xtext
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/FSM.xtext
@@ -41,7 +41,7 @@ ModelComponent:
 
 // the building blocks of a state machine: nodes and items
 StateGraphNode: State | ChoicePoint | TrPoint;
-StateGraphItem: StateGraphNode | Transition;
+StateGraphItem: StateGraphNode | TransitionBase;
 
 // state graph and state machine are two rules for the same model class
 StateGraph:
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/naming/FSMNameProvider.java b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/naming/FSMNameProvider.java
index 0313673ba..1ae299b76 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/naming/FSMNameProvider.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/naming/FSMNameProvider.java
@@ -23,6 +23,7 @@ import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
 import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
 import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
 import org.eclipse.etrice.core.fsm.fSM.RefinedState;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
 import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
@@ -65,6 +66,8 @@ public class FSMNameProvider {
 		public String caseTrPoint(TrPoint object) { return object.getName(); }
 		@Override
 		public String caseTransition(Transition object) { return getTransitionName(object); }
+		@Override
+		public String caseRefinedTransition(RefinedTransition object) { return getTransitionName(object.getTarget()); }
 	}
 	
 	private FSMNameProviderSwitch fsmNameProvider = new FSMNameProviderSwitch();
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.xtend b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.xtend
index 20cb892f0..7b8e65620 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.xtend
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.xtend
@@ -39,6 +39,8 @@ class ImplPostprocessor {
 				return ((ChoicePoint)this).getName();
 			else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.Transition%>)
 				return ((Transition)this).getName();
+			else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>)
+				return ((RefinedTransition)this).getTarget().getName();
 			return "";
 			''')
 		
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/scoping/FSMScopeProvider.xtend b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/scoping/FSMScopeProvider.xtend
index 3db3dd11b..ae5fce6a9 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/scoping/FSMScopeProvider.xtend
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/scoping/FSMScopeProvider.xtend
@@ -87,13 +87,13 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 		val List<IEObjectDescription> scopes = newArrayList
 		
 		val parent = getStateGraph(ep)
-		if (ep.state!=null) {
+		if (ep.state!==null) {
 			var epState = ep.state
 			
 			// check if there is a refined state for this state
 			epState = parent.getRefinedStateFor(epState)
 			
-			if (epState.getSubgraph()!=null) {
+			if (epState.getSubgraph()!==null) {
 				val tps = epState.subgraph.getAllTrPoints
 				for (tp : tps) {
 					scopes.add(EObjectDescription.create(tp.name, tp))
@@ -149,11 +149,11 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 		var sg = getStateGraph(rs)
 		if (sg.eContainer instanceof ModelComponent) {
 			var comp = sg.eContainer as ModelComponent
-			if (comp.base != null && !comp.isCircularClassHierarchy) {
+			if (comp.base !== null && !comp.isCircularClassHierarchy) {
 				comp = comp.base
 				val HashSet<State> covered = newHashSet
 				val ArrayList<State> states = newArrayList
-				while (comp!=null) {
+				while (comp!==null) {
 					recursivelyAddStates(comp.stateMachine, covered, states)
 					comp = comp.base
 				}
@@ -164,7 +164,7 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 		}
 		else if (sg.eContainer instanceof RefinedState) {
 			sg = (sg.eContainer as RefinedState).target.subgraph
-			if (sg!=null)
+			if (sg!==null)
 				for (s : sg.states) {
 					scopes.add(EObjectDescription.create(s.name, s))
 				}
@@ -185,8 +185,8 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 		var comp = trans.eContainer.eContainer as ModelComponent
 		if(!comp.isCircularClassHierarchy){
 			comp = comp.base
-			while (comp!=null) {
-				if (comp.stateMachine!=null) {
+			while (comp!==null) {
+				if (comp.stateMachine!==null) {
 					val acNameSegments = comp.fullyQualifiedName.segmentCount
 					val iter = comp.stateMachine.eAllContents
 					while (iter.hasNext) {
@@ -221,7 +221,7 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 		
 		// recursion
 		for (s : sg.states) {
-			if (s.getSubgraph()!=null)
+			if (s.getSubgraph()!==null)
 				recursivelyAddStates(s.getSubgraph(), covered, states)
 		}
 	}
@@ -233,7 +233,7 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 	 */
 	def private StateGraph getStateGraph(EObject obj) {
 		var EObject ctx = obj.eContainer
-		while (!(ctx instanceof StateGraph) && ctx.eContainer!=null) {
+		while (!(ctx instanceof StateGraph) && ctx.eContainer!==null) {
 			ctx = ctx.eContainer
 		}
 		if (ctx instanceof StateGraph)
@@ -253,7 +253,7 @@ class FSMScopeProvider extends AbstractDeclarativeScopeProvider {
 			return getStatePath(parent as SimpleState).append(bs.name)
 		else if (parent instanceof RefinedState) {
 			val State target = (parent as RefinedState).target
-			if (target!=null)
+			if (target!==null)
 				return getStatePath(target).append(bs.name)
 		}
 		return QualifiedName.create(bs.name)
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/util/FSMHelpers.java b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/util/FSMHelpers.java
index 55f79201d..c6c28b6a0 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/util/FSMHelpers.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/util/FSMHelpers.java
@@ -45,6 +45,9 @@ import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
 import org.eclipse.etrice.core.fsm.fSM.TrPoint;
 import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.fsm.fSM.TransitionChainStartTransition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionPoint;
 import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
 import org.eclipse.etrice.core.fsm.fSM.Trigger;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
@@ -77,6 +80,38 @@ public class FSMHelpers extends BaseHelpers {
 	}
 
 	/**
+	 * returns the actual state machine of this model class. I.e. the own state machine if it has
+	 * one or otherwise the first state machine in the super class hierarchy
+	 */
+	public StateGraph getActualStateMachine(ModelComponent mc) {
+		// we go up in the inheritance hierarchy until we find a model class with a state machine
+		while (mc!=null) {
+			if (mc.getStateMachine()!=null) {
+				return mc.getStateMachine();
+			}
+			
+			mc = mc.getBase();
+		}
+		
+		return null;
+	}
+	
+	public StateGraph getSuperStateMachine(ModelComponent mc) {
+		StateGraph stateMachine = getActualStateMachine(mc);
+		
+		// this component is not necessarily the one that was passed in
+		mc = getModelComponent(stateMachine);
+		
+		// now return the actual state machine of the base class...
+		if (mc!=null && mc.getBase()!=null) {
+			return getActualStateMachine(mc.getBase());
+		}
+		
+		// ...or null if no such one
+		return null;
+	}
+	
+	/**
 	 * Returns the parent {@link ModelComponent} of a {@link StateGraphItem}.
 	 * 
 	 * @param item a {@link StateGraphItem}
@@ -208,12 +243,21 @@ public class FSMHelpers extends BaseHelpers {
 	}
 	
 	/**
+	 * @param sg a {@link StateGraph}
+	 * @return <code>true</code> if the state graph represents the top level (i.e.
+	 * is the actor's state machine)
+	 */
+	public boolean isTopLevel(StateGraph sg) {
+		return !(sg.eContainer() instanceof State);
+	}
+	
+	/**
 	 * @param s a {@link State}
 	 * @return <code>true</code> if the state resides in the top level (i.e.
 	 * directly in the actor's state machine)
 	 */
 	public boolean isTopLevel(StateGraphNode s) {
-		return !(s.eContainer().eContainer() instanceof State);
+		return isTopLevel((StateGraph) s.eContainer());
 	}
 	
 	/**
@@ -332,6 +376,21 @@ public class FSMHelpers extends BaseHelpers {
 		return targetting;
 	}
 	
+	public SimpleState getFinalTarget(RefinedState state)  {
+		State target = state.getTarget();
+		if (target instanceof SimpleState) {
+			return (SimpleState) target;
+		}
+		else if (target instanceof RefinedState) {
+			return getFinalTarget((RefinedState) target);
+		}
+		else {
+			// must never happen
+			assert(false) : "unexpected sub type";
+			return null;
+		}
+	}
+	
 	/**
 	 * Returns <code>false</code> if the {@link DetailCode} is null or empty.
 	 * 
@@ -532,7 +591,37 @@ public class FSMHelpers extends BaseHelpers {
 	 * @return whether a {@link Trigger} contains a guard
 	 */
 	public boolean isGuarded(Trigger trig) {
-		return trig.getGuard()!=null && hasDetailCode(trig.getGuard().getGuard());
+		// TODO: remove this redundant method
+		return hasGuard(trig);
+	}
+	
+	public boolean isHandler(Transition tr) {
+		if (tr instanceof TransitionChainStartTransition) {
+			TransitionChainStartTransition trans = (TransitionChainStartTransition) tr;
+			if (trans.getFrom() instanceof TrPointTerminal) {
+				TrPoint tp = ((TrPointTerminal)trans.getFrom()).getTrPoint();
+				if (tp instanceof TransitionPoint)
+					return ((TransitionPoint)tp).isHandler();
+			}
+			else if (trans.getFrom() instanceof SubStateTrPointTerminal) {
+				TrPoint tp = ((SubStateTrPointTerminal)trans.getFrom()).getTrPoint();
+				if (tp instanceof TransitionPoint)
+					assert(false): "not allowed to connect TransitionPoint to exterior";
+			}
+		}
+		return false;
+	}
+	
+	public State getSuperState(TransitionBase tr) {
+		if (tr instanceof RefinedTransition) {
+			return getSuperState(((RefinedTransition) tr).getTarget());
+		}
+		
+		if (tr.eContainer().eContainer() instanceof State) {
+			return (State) tr.eContainer().eContainer();
+		}
+
+		return null;
 	}
 
 	/**
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMJavaValidator.java b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMJavaValidator.java
index 4be718ea4..54ae0b083 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMJavaValidator.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMJavaValidator.java
@@ -48,8 +48,8 @@ public class FSMJavaValidator extends org.eclipse.etrice.core.fsm.validation.Abs
 	public static final String PLAIN_STRING_DETAILCODE = "RoomJavaValidator.PlainStringDetailCode";
 	
 	@Inject
-	private FSMValidationUtil ValidationUtil;
-	
+	private FSMValidationUtil validationUtil;
+
 	@Inject
 	FSMGrammarAccess grammar;
 	
@@ -73,36 +73,43 @@ public class FSMJavaValidator extends org.eclipse.etrice.core.fsm.validation.Abs
 	}
 	
 	@Check
+	public void checkRefinedStateNotEmpty(RefinedState rs) {
+		if (validationUtil.isRefinedStateEmpty(rs)) {
+			error("Refined state must not be empty (needs to have at least one action code or a subgraph).", FSMPackage.Literals.STATE__ENTRY_CODE);
+		}
+	}
+	
+	@Check
 	public void checkStateNameUnique(SimpleState s) {
-//		Result result = ValidationUtil.isUniqueName(s, s.getName());
+//		Result result = validationUtil.isUniqueName(s, s.getName());
 //		if (!result.isOk())
 //			error(result.getMsg(), FSMPackage.Literals.SIMPLE_STATE__NAME);
 	}
 	
 	@Check
 	public void checkTrPoint(TrPoint tp) {
-		Result result = ValidationUtil.isValid(tp);
+		Result result = validationUtil.isValid(tp);
 		if (!result.isOk())
 			error(result);
 	}
 	
 	@Check
 	public void checkChoicePoint(ChoicePoint cp) {
-//		if (!ValidationUtil.isUniqueName(cp, cp.getName()).isOk())
+//		if (!validationUtil.isUniqueName(cp, cp.getName()).isOk())
 //			error("name is not unique", FSMPackage.Literals.CHOICE_POINT__NAME);
 	}
 	
 	@Check
 	public void checkTransition(Transition trans) {
-		Result result = ValidationUtil.checkTransition(trans);
+		Result result = validationUtil.checkTransition(trans);
 		if (!result.isOk())
 			error(result);
 
 		if (trans instanceof InitialTransition) {
-			result = ValidationUtil.isConnectable(null, trans.getTo(), trans, (StateGraph)trans.eContainer());
+			result = validationUtil.isConnectable(null, trans.getTo(), trans, (StateGraph)trans.eContainer());
 		}
 		else {
-			result = ValidationUtil.isConnectable(((NonInitialTransition)trans).getFrom(), trans.getTo(), trans, (StateGraph)trans.eContainer());
+			result = validationUtil.isConnectable(((NonInitialTransition)trans).getFrom(), trans.getTo(), trans, (StateGraph)trans.eContainer());
 		}
 		if (!result.isOk())
 			error(result);
@@ -112,11 +119,11 @@ public class FSMJavaValidator extends org.eclipse.etrice.core.fsm.validation.Abs
 	
 	@Check
 	public void checkState(org.eclipse.etrice.core.fsm.fSM.State state) {
-		Result result = ValidationUtil.checkState(state);
+		Result result = validationUtil.checkState(state);
 		if (!result.isOk())
 			error(result);
 	
-		ArrayList<Result> res = ValidationUtil.uniqueOriginTriggers(state);
+		ArrayList<Result> res = validationUtil.uniqueOriginTriggers(state);
 		for (Result r : res) {
 			error(r);
 		}
@@ -158,7 +165,7 @@ public class FSMJavaValidator extends org.eclipse.etrice.core.fsm.validation.Abs
 		}
 		if(isPlainStyle) {
 			// TODO quickfix here does not work yet, see FSMQuickfixProvider
-//			warning("old style line string", dc, null, PLAIN_STRING_DETAILCODE);
+			warning("old style line string", dc, null, PLAIN_STRING_DETAILCODE);
 		}
 		
 	}
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtil.java b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtil.java
index e6353b163..7436241b7 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtil.java
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtil.java
@@ -336,4 +336,15 @@ public class FSMValidationUtil extends FSMValidationUtilXtend {
 		return name.matches("\\^?[a-zA-Z_][a-zA-Z_0-9]*");
 	}
 
+	public boolean isRefinedStateEmpty(RefinedState rs) {
+		if (rs.getSubgraph()==null || fsmHelpers.isEmpty(rs.getSubgraph())) {
+			boolean entryEmpty = fsmHelpers.getDetailCode(rs.getEntryCode()).trim().isEmpty();
+			boolean exitEmpty = fsmHelpers.getDetailCode(rs.getExitCode()).trim().isEmpty();
+			boolean doEmpty = fsmHelpers.getDetailCode(rs.getDoCode()).trim().isEmpty();
+			if (entryEmpty && exitEmpty && doEmpty) {
+				return true;
+			}
+		}
+		return false;
+	}
 }
diff --git a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtilXtend.xtend b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtilXtend.xtend
index 11016c077..d9743d7e2 100644
--- a/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtilXtend.xtend
+++ b/plugins/org.eclipse.etrice.core.fsm/src/org/eclipse/etrice/core/fsm/validation/FSMValidationUtilXtend.xtend
@@ -84,7 +84,7 @@ class FSMValidationUtilXtend {
 		val ArrayList<FSMValidationUtilXtend.Result> result = newArrayList
 		
 		for (Transition t:parent.transitions.filter(t|t instanceof TriggeredTransition && ((t as TriggeredTransition).from instanceof StateTerminal) && myState==((t as TriggeredTransition).from as StateTerminal).state)) {
-			for (Trigger k:(t as TriggeredTransition).triggers.filter(k|k.guard==null)) {
+			for (Trigger k:(t as TriggeredTransition).triggers.filter(k|k.guard===null)) {
 				for (specMethod:k.getMsgFromIfPairs) {
 					val triggerName = specMethod.triggerName
 					if (trig2trans.containsKey(triggerName)) {
@@ -105,7 +105,7 @@ class FSMValidationUtilXtend {
 	
 	def getStateGraph(EObject obj) {
 		var parent = obj.eContainer
-		while (parent!=null) {
+		while (parent!==null) {
 			if (parent instanceof StateGraph) {
 				return parent as StateGraph
 			}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/.classpath b/plugins/org.eclipse.etrice.core.genmodel.fsm/.classpath
index 751c8f2e5..eda61faab 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/.classpath
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/.classpath
@@ -4,4 +4,6 @@
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="output" path="bin"/>
+	<classpathentry kind="src" path="xtend-gen"/>
+	<classpathentry kind="src" path="src-gen"/>
 </classpath>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/.project b/plugins/org.eclipse.etrice.core.genmodel.fsm/.project
index 3b2beec41..854994ad4 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/.project
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/.project
@@ -6,6 +6,11 @@
 	</projects>
 	<buildSpec>
 		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
@@ -22,7 +27,8 @@
 		</buildCommand>
 	</buildSpec>
 	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
 	</natures>
 </projectDescription>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.core.genmodel.fsm/META-INF/MANIFEST.MF
index 8a8025781..7e57925f9 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/META-INF/MANIFEST.MF
@@ -4,17 +4,17 @@ Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.etrice.core.genmodel.fsm;singleton:=true
 Bundle-Version: 1.1.3.qualifier
 Bundle-ClassPath: .
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.etrice.core.genmodel.fsm,
+ org.eclipse.etrice.core.genmodel.fsm.fsmgen,
+ org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl,
+ org.eclipse.etrice.core.genmodel.fsm.fsmgen.util
 Require-Bundle: org.eclipse.etrice.core.common;visibility:=reexport,
  org.eclipse.etrice.core.fsm;bundle-version="1.1.3";visibility:=reexport,
  org.eclipse.core.runtime,
  org.eclipse.emf.ecore;visibility:=reexport,
- org.eclipse.emf.ecore.xmi;visibility:=reexport
+ org.eclipse.emf.ecore.xmi;visibility:=reexport,
+ org.eclipse.xtext.xbase.lib
 Bundle-ActivationPolicy: lazy
-Export-Package: org.eclipse.etrice.core.genmodel.fsm.base,
- org.eclipse.etrice.core.genmodel.fsm.builder,
- org.eclipse.etrice.core.genmodel.fsm.fsmgen,
- org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl,
- org.eclipse.etrice.core.genmodel.fsm.fsmgen.util
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/build.gradle b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.gradle
index 62ee3776f..e2610ee9d 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/build.gradle
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.gradle
@@ -2,4 +2,12 @@ dependencies {
 	compile project(':plugins:org.eclipse.etrice.core.fsm')
 	
 	compile "org.eclipse.xtext:org.eclipse.xtext:$versions.xtext"
+}
+
+sourceSets {
+	main {
+		java {
+			srcDirs 'src-gen'
+		}
+	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties
index 857b8ceb4..45705e5a9 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties
@@ -1,18 +1,10 @@
-#  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
-#  All rights reserved. This program and the accompanying materials
-#  are made available under the terms of the Eclipse Public License v1.0
-#  which accompanies this distribution, and is available at
-#  http://www.eclipse.org/legal/epl-v10.html
-#  
-#  CONTRIBUTORS:
-#  		Henrik Rentz-Reichert (initial contribution)
-#  
-
 bin.includes = .,\
                model/,\
                META-INF/,\
                plugin.xml,\
                plugin.properties
 jars.compile.order = .
-source.. = src/
+source.. = src-gen/,\
+           xtend-gen/,\
+           src/
 output.. = bin/
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore b/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore
index 3f8349ccd..b8968421e 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore
@@ -2,116 +2,79 @@
 <ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="fsmgen" nsURI="http://www.eclipse.org/etrice/generator/fsm"
     nsPrefix="fsmgen">
-  <eClassifiers xsi:type="ecore:EClass" name="ActiveTrigger">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="msg" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="ifitem" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="trigger" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="transitions" upperBound="-1"
-        eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//TriggeredTransition"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExpandedModelComponent">
-    <eOperations name="prepare">
-      <eParameters name="validator" eType="#//IDiagnostician"/>
-    </eOperations>
-    <eOperations name="release"/>
-    <eOperations name="addOwnObject">
-      <eParameters name="obj" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraphItem"/>
-    </eOperations>
-    <eOperations name="isOwnObject" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eParameters name="obj" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraphItem"/>
-    </eOperations>
-    <eOperations name="hasBaseTransitionDetailCode" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="hasStateMachine" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eOperations name="getTriggerCodeName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eParameters name="mif" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//MessageFromIf"/>
-    </eOperations>
-    <eOperations name="getTriggerCodeName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eParameters name="at" eType="#//ActiveTrigger"/>
-    </eOperations>
-    <eOperations name="getOutgoingTransitions" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition">
-      <eParameters name="node" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraphNode"/>
-    </eOperations>
-    <eOperations name="getIncomingTransitions" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition">
-      <eParameters name="node" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraphNode"/>
-    </eOperations>
-    <eOperations name="getActiveTriggers" upperBound="-1" eType="#//ActiveTrigger">
-      <eParameters name="state" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//State"/>
-    </eOperations>
-    <eOperations name="getTriggers" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//MessageFromIf"/>
-    <eOperations name="getOwnTriggers" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//MessageFromIf"/>
-    <eOperations name="getMessageID" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eParameters name="mif" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//MessageFromIf"/>
-    </eOperations>
-    <eOperations name="getChain" eType="#//TransitionChain">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="getChains" upperBound="-1" eType="#//TransitionChain">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="getOwnTransitionChains" upperBound="-1" eType="#//TransitionChain"/>
-    <eOperations name="getOwnInterfaceItems" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem">
-      <eParameters name="mc" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//ModelComponent"/>
-    </eOperations>
-    <eOperations name="getAllInterfaceItems" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
-    <eOperations name="isMatching" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eParameters name="trig" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Trigger"/>
-      <eParameters name="trigstr" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getDefaultBranch" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//ContinuationTransition">
-      <eParameters name="out" upperBound="-1" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="getOrig" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
-      <eParameters name="copy" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
-    </eOperations>
-    <eOperations name="getCopy" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
-      <eParameters name="orig" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
-    </eOperations>
-    <eOperations name="getModelComponentName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eOperations name="getData" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="getIncomingMessages" upperBound="-1" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
-      <eParameters name="ifitem" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
-    </eOperations>
-    <eOperations name="addTransitionChain" eType="#//TransitionChain">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    </eOperations>
-    <eOperations name="getInterfaceItemLocalId" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt">
-      <eParameters name="ifitem" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
-    </eOperations>
-    <eOperations name="computeCommonChainData" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
-      <eParameters name="chains" upperBound="-1" eType="#//TransitionChain"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="modelComponent" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//ModelComponent"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="stateMachine" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraph"
+  <eClassifiers xsi:type="ecore:EClass" name="GraphContainer" eSuperTypes="#//FSMGenElement">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="graph" eType="#//Graph"
         containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="transitionChains" upperBound="-1"
-        eType="#//TransitionChain" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="component" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//ModelComponent"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="initializedTriggersInStates"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="initializedChainHeads"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="initializedCommonData"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExpandedRefinedState" eSuperTypes="../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//SimpleState">
-    <eOperations name="init">
-      <eParameters name="rs" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//RefinedState"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="inheritedEntry" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//DetailCode"
-        containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="inheritedExit" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//DetailCode"
-        containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="inheritedDo" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//DetailCode"
-        containment="true"/>
+  <eClassifiers xsi:type="ecore:EClass" name="Graph" eSuperTypes="#//FSMGenElement">
+    <eOperations name="toString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="body" value="StringBuilder result = new StringBuilder();&#xD;&#xA;result.append(&quot;StateGraph {\n&quot;);&#xD;&#xA;for (Node n : getNodes()) {&#xD;&#xA;&#x9;result.append(&quot;  &quot; + n.toString() + &quot;\n&quot;);&#xD;&#xA;}&#xD;&#xA;for (Link l : getLinks()) {&#xD;&#xA;&#x9;result.append(&quot;  &quot; + l.toString() + &quot;\n&quot;);&#xD;&#xA;}&#xD;&#xA;result.append(&quot;}&quot;);&#xD;&#xA;return result.toString();"/>
+      </eAnnotations>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="nodes" upperBound="-1"
+        eType="#//Node" containment="true" eOpposite="#//Node/graph"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="links" upperBound="-1"
+        eType="#//Link" containment="true" eOpposite="#//Link/graph"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="stateGraph" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraph"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="node" eType="#//Node" eOpposite="#//Node/subgraph"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="IDiagnostician" instanceTypeName="IDiagnostician"
-      abstract="true" interface="true"/>
-  <eClassifiers xsi:type="ecore:EClass" name="ITransitionChainVisitor" instanceTypeName="ITransitionChainVisitor"
-      abstract="true" interface="true"/>
-  <eClassifiers xsi:type="ecore:EClass" name="TransitionChain">
-    <eOperations name="getStateContext" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//State"/>
-    <eOperations name="isHandler" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eOperations name="genExecuteChain" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eParameters name="tcv" eType="#//ITransitionChainVisitor"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="transition" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="data" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+  <eClassifiers xsi:type="ecore:EClass" name="GraphItem" eSuperTypes="#//FSMGenElement">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="inherited" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="Node" eSuperTypes="#//GraphItem">
+    <eOperations name="toString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="body" value="String type = &quot;?&quot;;&#xD;&#xA;if (getStateGraphNode() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.RefinedState%>) {&#xD;&#xA;&#x9;type = &quot;RefinedState&quot;;&#xD;&#xA;}&#xD;&#xA;else if (getStateGraphNode() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.SimpleState%>) {&#xD;&#xA;&#x9;type = &quot;SimpleState&quot;;&#xD;&#xA;}&#xD;&#xA;else if (getStateGraphNode() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.TrPoint%>) {&#xD;&#xA;&#x9;type = &quot;TrPoint&quot;;&#xD;&#xA;}&#xD;&#xA;else if (getStateGraphNode() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>) {&#xD;&#xA;&#x9;type = &quot;ChoicePoint&quot;;&#xD;&#xA;}&#xD;&#xA;return &quot;Node &quot; + getStateGraphNode().getName() + &quot; (&quot; + type + &quot;)&quot;;"/>
+      </eAnnotations>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="graph" eType="#//Graph"
+        eOpposite="#//Graph/nodes"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="subgraph" eType="#//Graph"
+        containment="true" eOpposite="#//Graph/node"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="outgoing" upperBound="-1"
+        eType="#//Link" eOpposite="#//Link/source"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="incoming" upperBound="-1"
+        eType="#//Link" eOpposite="#//Link/target"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="stateGraphNode" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//StateGraphNode"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="caughtTriggers" upperBound="-1"
+        eType="#//CommonTrigger" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="inheritanceLevel" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="Link" eSuperTypes="#//GraphItem">
+    <eOperations name="toString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="body" value="if (getTransition() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.InitialTransition%>) {&#xD;&#xA;&#x9;return &quot;Link initial -> &quot; + getTarget().toString() + &quot; (InitialTransition)&quot;;&#xD;&#xA;}&#xD;&#xA;else if (getTransition() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.NonInitialTransition%>) {&#xD;&#xA;&#x9;return &quot;Link &quot; + getSource().toString() + &quot; -> &quot; + getTarget().toString() + &quot; (InitialTransition)&quot;;&#xD;&#xA;}&#xD;&#xA;else if (getTransition() instanceof &lt;%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>) {&#xD;&#xA;&#x9;return &quot;RefinedTransition&quot;;&#xD;&#xA;}&#xD;&#xA;return &quot;?&quot;;"/>
+      </eAnnotations>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="graph" eType="#//Graph"
+        eOpposite="#//Graph/links"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="source" eType="#//Node"
+        eOpposite="#//Node/outgoing"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="target" eType="#//Node"
+        eOpposite="#//Node/incoming"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="chainHeads" upperBound="-1"
+        eType="#//Link"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="ifitemTriggered" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="commonData" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="transition" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//TransitionBase"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CommonTrigger" eSuperTypes="#//FSMGenElement">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="msg" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="ifitem" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="hasGuard" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="trigger" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="links" upperBound="-1"
+        eType="#//Link"/>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="FSMGenElement"/>
 </ecore:EPackage>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.genmodel b/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.genmodel
index 76c00dbb8..109b764a1 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.genmodel
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.genmodel
@@ -1,106 +1,52 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText=" Copyright (c) 2014 protos software gmbh (http://www.protos.de).&#xD;&#xA; All rights reserved. This program and the accompanying materials&#xD;&#xA; are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA; which accompanies this distribution, and is available at&#xD;&#xA; http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA; &#xD;&#xA; CONTRIBUTORS:&#xD;&#xA; &#x9;&#x9;Henrik Rentz-Reichert (initial contribution)&#xD;&#xA; "
-    modelDirectory="/org.eclipse.etrice.core.genmodel.fsm/src" modelPluginID="org.eclipse.etrice.core.genmodel.fsm"
-    modelName="FsmGen" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
-    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" copyrightFields="false"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.etrice.core.genmodel.fsm/src-gen"
+    editDirectory="/org.eclipse.etrice.core.genmodel.fsm.edit/src" editorDirectory="/org.eclipse.etrice.core.genmodel.fsm.editor/src"
+    modelPluginID="org.eclipse.etrice.core.genmodel.fsm" modelName="Fsmgen" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="7.0" copyrightFields="false"
+    editPluginID="org.eclipse.etrice.core.genmodel.fsm.edit" editorPluginID="org.eclipse.etrice.core.genmodel.fsm.editor"
     usedGenPackages="../../org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/Base.genmodel#//base ../../org.eclipse.etrice.core.fsm/model/generated/FSM.genmodel#//fSM"
-    importOrganizing="true">
+    operationReflection="true" importOrganizing="true">
   <foreignModel>fsmgen.ecore</foreignModel>
   <genPackages prefix="FsmGen" basePackage="org.eclipse.etrice.core.genmodel.fsm"
-      resource="XMI" disposableProviderFactory="true" ecorePackage="fsmgen.ecore#/">
-    <genClasses ecoreClass="fsmgen.ecore#//ActiveTrigger">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ActiveTrigger/msg"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ActiveTrigger/ifitem"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute fsmgen.ecore#//ActiveTrigger/trigger"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ActiveTrigger/transitions"/>
+      disposableProviderFactory="true" fileExtensions="fsmgen2" ecorePackage="fsmgen.ecore#/">
+    <genClasses ecoreClass="fsmgen.ecore#//GraphContainer">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//GraphContainer/graph"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//GraphContainer/component"/>
     </genClasses>
-    <genClasses image="false" ecoreClass="fsmgen.ecore#//ExpandedModelComponent">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedModelComponent/modelComponent"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedModelComponent/stateMachine"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedModelComponent/transitionChains"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/prepare">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/prepare/validator"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/release"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/addOwnObject">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/addOwnObject/obj"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/isOwnObject">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/isOwnObject/obj"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/hasStateMachine"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getTriggerCodeName">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getTriggerCodeName/mif"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getTriggerCodeName.1">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getTriggerCodeName.1/at"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getOutgoingTransitions">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getOutgoingTransitions/node"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getIncomingTransitions">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getIncomingTransitions/node"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getActiveTriggers">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getActiveTriggers/state"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getTriggers"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getOwnTriggers"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getMessageID">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getMessageID/mif"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getChain">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getChain/trans"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getOwnTransitionChains"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getOwnInterfaceItems"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getAllInterfaceItems"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/isMatching">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/isMatching/trig"/>
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/isMatching/trigstr"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getDefaultBranch">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getDefaultBranch/out"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getOrig">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getOrig/copy"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getModelComponentName"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getData">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getData/trans"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getIncomingMessages">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getIncomingMessages/ifitem"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/addTransitionChain">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/addTransitionChain/trans"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/getInterfaceItemLocalId">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/getInterfaceItemLocalId/ifitem"/>
-      </genOperations>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedModelComponent/computeCommonChainData">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedModelComponent/computeCommonChainData/chains"/>
-      </genOperations>
+    <genClasses ecoreClass="fsmgen.ecore#//Graph">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Graph/nodes"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Graph/links"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Graph/stateGraph"/>
+      <genOperations ecoreOperation="fsmgen.ecore#//Graph/toString"/>
     </genClasses>
-    <genClasses ecoreClass="fsmgen.ecore#//ExpandedRefinedState">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedRefinedState/inheritedEntry"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedRefinedState/inheritedExit"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//ExpandedRefinedState/inheritedDo"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//ExpandedRefinedState/init">
-        <genParameters ecoreParameter="fsmgen.ecore#//ExpandedRefinedState/init/rs"/>
-      </genOperations>
+    <genClasses ecoreClass="fsmgen.ecore#//GraphItem">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute fsmgen.ecore#//GraphItem/inherited"/>
     </genClasses>
-    <genClasses image="false" ecoreClass="fsmgen.ecore#//IDiagnostician"/>
-    <genClasses image="false" ecoreClass="fsmgen.ecore#//ITransitionChainVisitor"/>
-    <genClasses ecoreClass="fsmgen.ecore#//TransitionChain">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//TransitionChain/transition"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//TransitionChain/data"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//TransitionChain/getStateContext"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//TransitionChain/isHandler"/>
-      <genOperations ecoreOperation="fsmgen.ecore#//TransitionChain/genExecuteChain">
-        <genParameters ecoreParameter="fsmgen.ecore#//TransitionChain/genExecuteChain/tcv"/>
-      </genOperations>
+    <genClasses ecoreClass="fsmgen.ecore#//Node">
+      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/graph"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/subgraph"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/outgoing"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/incoming"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/stateGraphNode"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Node/caughtTriggers"/>
+      <genOperations ecoreOperation="fsmgen.ecore#//Node/toString"/>
+    </genClasses>
+    <genClasses ecoreClass="fsmgen.ecore#//Link">
+      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/graph"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/source"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/target"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/chainHeads"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute fsmgen.ecore#//Link/ifitemTriggered"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/commonData"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//Link/transition"/>
+      <genOperations ecoreOperation="fsmgen.ecore#//Link/toString"/>
+    </genClasses>
+    <genClasses ecoreClass="fsmgen.ecore#//CommonTrigger">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//CommonTrigger/msg"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//CommonTrigger/ifitem"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute fsmgen.ecore#//CommonTrigger/trigger"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference fsmgen.ecore#//CommonTrigger/transitions"/>
     </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.properties b/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.properties
index 661884708..5f7d8ec87 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.properties
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.properties
@@ -1,12 +1,4 @@
-#  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
-#  All rights reserved. This program and the accompanying materials
-#  are made available under the terms of the Eclipse Public License v1.0
-#  which accompanies this distribution, and is available at
-#  http://www.eclipse.org/legal/epl-v10.html
-#  
-#  CONTRIBUTORS:
-#  		Henrik Rentz-Reichert (initial contribution)
-#  
+#
 
-pluginName = FsmGen Model
-providerName = www.example.org
+pluginName = Fine State Machine Generator Model
+providerName = Eclipse eTrice
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.xml b/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.xml
index 9cd2ee340..ca5612d8b 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.xml
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/plugin.xml
@@ -2,15 +2,6 @@
 <?eclipse version="3.0"?>
 
 <!--
-  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
-  All rights reserved. This program and the accompanying materials
-  are made available under the terms of the Eclipse Public License v1.0
-  which accompanies this distribution, and is available at
-  http://www.eclipse.org/legal/epl-v10.html
-  
-  CONTRIBUTORS:
-  		Henrik Rentz-Reichert (initial contribution)
-  
 -->
 
 <plugin>
@@ -23,11 +14,4 @@
             genModel="model/fsmgen.genmodel"/>
    </extension>
 
-   <extension point="org.eclipse.emf.ecore.extension_parser">
-      <!-- @generated fsmgen -->
-      <parser
-            type="fsmgen"
-            class="org.eclipse.etrice.core.genmodel.fsm.fsmgen.util.FsmGenResourceFactoryImpl"/>
-   </extension>
-
 </plugin>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/CommonTrigger.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/CommonTrigger.java
new file mode 100644
index 000000000..84a78c3c4
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/CommonTrigger.java
@@ -0,0 +1,152 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Common Trigger</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getMsg <em>Msg</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getIfitem <em>Ifitem</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#isHasGuard <em>Has Guard</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getTrigger <em>Trigger</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getLinks <em>Links</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger()
+ * @model
+ * @generated
+ */
+public interface CommonTrigger extends FSMGenElement {
+	/**
+	 * Returns the value of the '<em><b>Msg</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Msg</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Msg</em>' reference.
+	 * @see #setMsg(EObject)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger_Msg()
+	 * @model
+	 * @generated
+	 */
+	EObject getMsg();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getMsg <em>Msg</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Msg</em>' reference.
+	 * @see #getMsg()
+	 * @generated
+	 */
+	void setMsg(EObject value);
+
+	/**
+	 * Returns the value of the '<em><b>Ifitem</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Ifitem</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Ifitem</em>' reference.
+	 * @see #setIfitem(AbstractInterfaceItem)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger_Ifitem()
+	 * @model
+	 * @generated
+	 */
+	AbstractInterfaceItem getIfitem();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getIfitem <em>Ifitem</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Ifitem</em>' reference.
+	 * @see #getIfitem()
+	 * @generated
+	 */
+	void setIfitem(AbstractInterfaceItem value);
+
+	/**
+	 * Returns the value of the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Trigger</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Trigger</em>' attribute.
+	 * @see #setTrigger(String)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger_Trigger()
+	 * @model
+	 * @generated
+	 */
+	String getTrigger();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getTrigger <em>Trigger</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Trigger</em>' attribute.
+	 * @see #getTrigger()
+	 * @generated
+	 */
+	void setTrigger(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Links</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Links</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Links</em>' reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger_Links()
+	 * @model
+	 * @generated
+	 */
+	EList<Link> getLinks();
+
+	/**
+	 * Returns the value of the '<em><b>Has Guard</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Has Guard</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Has Guard</em>' attribute.
+	 * @see #setHasGuard(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getCommonTrigger_HasGuard()
+	 * @model
+	 * @generated
+	 */
+	boolean isHasGuard();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#isHasGuard <em>Has Guard</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Has Guard</em>' attribute.
+	 * @see #isHasGuard()
+	 * @generated
+	 */
+	void setHasGuard(boolean value);
+
+} // CommonTrigger
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FSMGenElement.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FSMGenElement.java
new file mode 100644
index 000000000..c54c1f195
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FSMGenElement.java
@@ -0,0 +1,18 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>FSM Gen Element</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getFSMGenElement()
+ * @model
+ * @generated
+ */
+public interface FSMGenElement extends EObject {
+} // FSMGenElement
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java
new file mode 100644
index 000000000..c7b2e0478
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java
@@ -0,0 +1,96 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage
+ * @generated
+ */
+public interface FsmGenFactory extends EFactory {
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	FsmGenFactory eINSTANCE = org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Graph Container</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Graph Container</em>'.
+	 * @generated
+	 */
+	GraphContainer createGraphContainer();
+
+	/**
+	 * Returns a new object of class '<em>Graph</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Graph</em>'.
+	 * @generated
+	 */
+	Graph createGraph();
+
+	/**
+	 * Returns a new object of class '<em>Graph Item</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Graph Item</em>'.
+	 * @generated
+	 */
+	GraphItem createGraphItem();
+
+	/**
+	 * Returns a new object of class '<em>Node</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Node</em>'.
+	 * @generated
+	 */
+	Node createNode();
+
+	/**
+	 * Returns a new object of class '<em>Link</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Link</em>'.
+	 * @generated
+	 */
+	Link createLink();
+
+	/**
+	 * Returns a new object of class '<em>Common Trigger</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Common Trigger</em>'.
+	 * @generated
+	 */
+	CommonTrigger createCommonTrigger();
+
+	/**
+	 * Returns a new object of class '<em>FSM Gen Element</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>FSM Gen Element</em>'.
+	 * @generated
+	 */
+	FSMGenElement createFSMGenElement();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	FsmGenPackage getFsmGenPackage();
+
+} //FsmGenFactory
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java
new file mode 100644
index 000000000..0fdae6956
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java
@@ -0,0 +1,1333 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EOperation;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each operation of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface FsmGenPackage extends EPackage {
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "fsmgen";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://www.eclipse.org/etrice/generator/fsm";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "fsmgen";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	FsmGenPackage eINSTANCE = org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FSMGenElementImpl <em>FSM Gen Element</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FSMGenElementImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getFSMGenElement()
+	 * @generated
+	 */
+	int FSM_GEN_ELEMENT = 6;
+
+	/**
+	 * The number of structural features of the '<em>FSM Gen Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int FSM_GEN_ELEMENT_FEATURE_COUNT = 0;
+
+	/**
+	 * The number of operations of the '<em>FSM Gen Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int FSM_GEN_ELEMENT_OPERATION_COUNT = 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl <em>Graph Container</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraphContainer()
+	 * @generated
+	 */
+	int GRAPH_CONTAINER = 0;
+
+	/**
+	 * The feature id for the '<em><b>Graph</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER__GRAPH = FSM_GEN_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Component</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER__COMPONENT = FSM_GEN_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Initialized Triggers In States</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES = FSM_GEN_ELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Initialized Chain Heads</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS = FSM_GEN_ELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Initialized Common Data</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER__INITIALIZED_COMMON_DATA = FSM_GEN_ELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>Graph Container</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER_FEATURE_COUNT = FSM_GEN_ELEMENT_FEATURE_COUNT + 5;
+
+	/**
+	 * The number of operations of the '<em>Graph Container</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_CONTAINER_OPERATION_COUNT = FSM_GEN_ELEMENT_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl <em>Graph</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraph()
+	 * @generated
+	 */
+	int GRAPH = 1;
+
+	/**
+	 * The feature id for the '<em><b>Nodes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH__NODES = FSM_GEN_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Links</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH__LINKS = FSM_GEN_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>State Graph</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH__STATE_GRAPH = FSM_GEN_ELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Node</b></em>' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH__NODE = FSM_GEN_ELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>Graph</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_FEATURE_COUNT = FSM_GEN_ELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The operation id for the '<em>To String</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH___TO_STRING = FSM_GEN_ELEMENT_OPERATION_COUNT + 0;
+
+	/**
+	 * The number of operations of the '<em>Graph</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_OPERATION_COUNT = FSM_GEN_ELEMENT_OPERATION_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphItemImpl <em>Graph Item</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphItemImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraphItem()
+	 * @generated
+	 */
+	int GRAPH_ITEM = 2;
+
+	/**
+	 * The feature id for the '<em><b>Inherited</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_ITEM__INHERITED = FSM_GEN_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Graph Item</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_ITEM_FEATURE_COUNT = FSM_GEN_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Graph Item</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GRAPH_ITEM_OPERATION_COUNT = FSM_GEN_ELEMENT_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl <em>Node</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getNode()
+	 * @generated
+	 */
+	int NODE = 3;
+
+	/**
+	 * The feature id for the '<em><b>Inherited</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__INHERITED = GRAPH_ITEM__INHERITED;
+
+	/**
+	 * The feature id for the '<em><b>Graph</b></em>' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__GRAPH = GRAPH_ITEM_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Subgraph</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__SUBGRAPH = GRAPH_ITEM_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Outgoing</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__OUTGOING = GRAPH_ITEM_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Incoming</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__INCOMING = GRAPH_ITEM_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>State Graph Node</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__STATE_GRAPH_NODE = GRAPH_ITEM_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Caught Triggers</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__CAUGHT_TRIGGERS = GRAPH_ITEM_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Inheritance Level</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE__INHERITANCE_LEVEL = GRAPH_ITEM_FEATURE_COUNT + 6;
+
+	/**
+	 * The number of structural features of the '<em>Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE_FEATURE_COUNT = GRAPH_ITEM_FEATURE_COUNT + 7;
+
+	/**
+	 * The operation id for the '<em>To String</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE___TO_STRING = GRAPH_ITEM_OPERATION_COUNT + 0;
+
+	/**
+	 * The number of operations of the '<em>Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int NODE_OPERATION_COUNT = GRAPH_ITEM_OPERATION_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl <em>Link</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getLink()
+	 * @generated
+	 */
+	int LINK = 4;
+
+	/**
+	 * The feature id for the '<em><b>Inherited</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__INHERITED = GRAPH_ITEM__INHERITED;
+
+	/**
+	 * The feature id for the '<em><b>Graph</b></em>' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__GRAPH = GRAPH_ITEM_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Source</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__SOURCE = GRAPH_ITEM_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__TARGET = GRAPH_ITEM_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Chain Heads</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__CHAIN_HEADS = GRAPH_ITEM_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Ifitem Triggered</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__IFITEM_TRIGGERED = GRAPH_ITEM_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Common Data</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__COMMON_DATA = GRAPH_ITEM_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Transition</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK__TRANSITION = GRAPH_ITEM_FEATURE_COUNT + 6;
+
+	/**
+	 * The number of structural features of the '<em>Link</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK_FEATURE_COUNT = GRAPH_ITEM_FEATURE_COUNT + 7;
+
+	/**
+	 * The operation id for the '<em>To String</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK___TO_STRING = GRAPH_ITEM_OPERATION_COUNT + 0;
+
+	/**
+	 * The number of operations of the '<em>Link</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LINK_OPERATION_COUNT = GRAPH_ITEM_OPERATION_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl <em>Common Trigger</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getCommonTrigger()
+	 * @generated
+	 */
+	int COMMON_TRIGGER = 5;
+
+	/**
+	 * The feature id for the '<em><b>Msg</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER__MSG = FSM_GEN_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Ifitem</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER__IFITEM = FSM_GEN_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Has Guard</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER__HAS_GUARD = FSM_GEN_ELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER__TRIGGER = FSM_GEN_ELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Links</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER__LINKS = FSM_GEN_ELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>Common Trigger</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER_FEATURE_COUNT = FSM_GEN_ELEMENT_FEATURE_COUNT + 5;
+
+	/**
+	 * The number of operations of the '<em>Common Trigger</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMMON_TRIGGER_OPERATION_COUNT = FSM_GEN_ELEMENT_OPERATION_COUNT + 0;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer <em>Graph Container</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Graph Container</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+	 * @generated
+	 */
+	EClass getGraphContainer();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getGraph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Graph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getGraph()
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	EReference getGraphContainer_Graph();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getComponent <em>Component</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Component</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getComponent()
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	EReference getGraphContainer_Component();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedTriggersInStates <em>Initialized Triggers In States</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Initialized Triggers In States</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedTriggersInStates()
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	EAttribute getGraphContainer_InitializedTriggersInStates();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedChainHeads <em>Initialized Chain Heads</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Initialized Chain Heads</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedChainHeads()
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	EAttribute getGraphContainer_InitializedChainHeads();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedCommonData <em>Initialized Common Data</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Initialized Common Data</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedCommonData()
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	EAttribute getGraphContainer_InitializedCommonData();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Graph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+	 * @generated
+	 */
+	EClass getGraph();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNodes <em>Nodes</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Nodes</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNodes()
+	 * @see #getGraph()
+	 * @generated
+	 */
+	EReference getGraph_Nodes();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getLinks <em>Links</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Links</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getLinks()
+	 * @see #getGraph()
+	 * @generated
+	 */
+	EReference getGraph_Links();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getStateGraph <em>State Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>State Graph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getStateGraph()
+	 * @see #getGraph()
+	 * @generated
+	 */
+	EReference getGraph_StateGraph();
+
+	/**
+	 * Returns the meta object for the container reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode <em>Node</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the container reference '<em>Node</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode()
+	 * @see #getGraph()
+	 * @generated
+	 */
+	EReference getGraph_Node();
+
+	/**
+	 * Returns the meta object for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#toString() <em>To String</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the '<em>To String</em>' operation.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#toString()
+	 * @generated
+	 */
+	EOperation getGraph__ToString();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem <em>Graph Item</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Graph Item</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem
+	 * @generated
+	 */
+	EClass getGraphItem();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem#isInherited <em>Inherited</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Inherited</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem#isInherited()
+	 * @see #getGraphItem()
+	 * @generated
+	 */
+	EAttribute getGraphItem_Inherited();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node <em>Node</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Node</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+	 * @generated
+	 */
+	EClass getNode();
+
+	/**
+	 * Returns the meta object for the container reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the container reference '<em>Graph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_Graph();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph <em>Subgraph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Subgraph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_Subgraph();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getOutgoing <em>Outgoing</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Outgoing</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getOutgoing()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_Outgoing();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getIncoming <em>Incoming</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Incoming</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getIncoming()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_Incoming();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getStateGraphNode <em>State Graph Node</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>State Graph Node</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getStateGraphNode()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_StateGraphNode();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getCaughtTriggers <em>Caught Triggers</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Caught Triggers</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getCaughtTriggers()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EReference getNode_CaughtTriggers();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getInheritanceLevel <em>Inheritance Level</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Inheritance Level</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getInheritanceLevel()
+	 * @see #getNode()
+	 * @generated
+	 */
+	EAttribute getNode_InheritanceLevel();
+
+	/**
+	 * Returns the meta object for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#toString() <em>To String</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the '<em>To String</em>' operation.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#toString()
+	 * @generated
+	 */
+	EOperation getNode__ToString();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link <em>Link</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Link</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+	 * @generated
+	 */
+	EClass getLink();
+
+	/**
+	 * Returns the meta object for the container reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the container reference '<em>Graph</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_Graph();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource <em>Source</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Source</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_Source();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Target</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_Target();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getChainHeads <em>Chain Heads</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Chain Heads</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getChainHeads()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_ChainHeads();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#isIfitemTriggered <em>Ifitem Triggered</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Ifitem Triggered</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#isIfitemTriggered()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EAttribute getLink_IfitemTriggered();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getCommonData <em>Common Data</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Common Data</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getCommonData()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_CommonData();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTransition <em>Transition</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Transition</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTransition()
+	 * @see #getLink()
+	 * @generated
+	 */
+	EReference getLink_Transition();
+
+	/**
+	 * Returns the meta object for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#toString() <em>To String</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the '<em>To String</em>' operation.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#toString()
+	 * @generated
+	 */
+	EOperation getLink__ToString();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger <em>Common Trigger</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Common Trigger</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger
+	 * @generated
+	 */
+	EClass getCommonTrigger();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getMsg <em>Msg</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Msg</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getMsg()
+	 * @see #getCommonTrigger()
+	 * @generated
+	 */
+	EReference getCommonTrigger_Msg();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getIfitem <em>Ifitem</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Ifitem</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getIfitem()
+	 * @see #getCommonTrigger()
+	 * @generated
+	 */
+	EReference getCommonTrigger_Ifitem();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getTrigger <em>Trigger</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Trigger</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getTrigger()
+	 * @see #getCommonTrigger()
+	 * @generated
+	 */
+	EAttribute getCommonTrigger_Trigger();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getLinks <em>Links</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Links</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#getLinks()
+	 * @see #getCommonTrigger()
+	 * @generated
+	 */
+	EReference getCommonTrigger_Links();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement <em>FSM Gen Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>FSM Gen Element</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement
+	 * @generated
+	 */
+	EClass getFSMGenElement();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#isHasGuard <em>Has Guard</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Has Guard</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger#isHasGuard()
+	 * @see #getCommonTrigger()
+	 * @generated
+	 */
+	EAttribute getCommonTrigger_HasGuard();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	FsmGenFactory getFsmGenFactory();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * Defines literals for the meta objects that represent
+	 * <ul>
+	 *   <li>each class,</li>
+	 *   <li>each feature of each class,</li>
+	 *   <li>each operation of each class,</li>
+	 *   <li>each enum,</li>
+	 *   <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl <em>Graph Container</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraphContainer()
+		 * @generated
+		 */
+		EClass GRAPH_CONTAINER = eINSTANCE.getGraphContainer();
+
+		/**
+		 * The meta object literal for the '<em><b>Graph</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH_CONTAINER__GRAPH = eINSTANCE.getGraphContainer_Graph();
+
+		/**
+		 * The meta object literal for the '<em><b>Component</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH_CONTAINER__COMPONENT = eINSTANCE.getGraphContainer_Component();
+
+		/**
+		 * The meta object literal for the '<em><b>Initialized Triggers In States</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES = eINSTANCE.getGraphContainer_InitializedTriggersInStates();
+
+		/**
+		 * The meta object literal for the '<em><b>Initialized Chain Heads</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS = eINSTANCE.getGraphContainer_InitializedChainHeads();
+
+		/**
+		 * The meta object literal for the '<em><b>Initialized Common Data</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GRAPH_CONTAINER__INITIALIZED_COMMON_DATA = eINSTANCE.getGraphContainer_InitializedCommonData();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl <em>Graph</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraph()
+		 * @generated
+		 */
+		EClass GRAPH = eINSTANCE.getGraph();
+
+		/**
+		 * The meta object literal for the '<em><b>Nodes</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH__NODES = eINSTANCE.getGraph_Nodes();
+
+		/**
+		 * The meta object literal for the '<em><b>Links</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH__LINKS = eINSTANCE.getGraph_Links();
+
+		/**
+		 * The meta object literal for the '<em><b>State Graph</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH__STATE_GRAPH = eINSTANCE.getGraph_StateGraph();
+
+		/**
+		 * The meta object literal for the '<em><b>Node</b></em>' container reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference GRAPH__NODE = eINSTANCE.getGraph_Node();
+
+		/**
+		 * The meta object literal for the '<em><b>To String</b></em>' operation.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EOperation GRAPH___TO_STRING = eINSTANCE.getGraph__ToString();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphItemImpl <em>Graph Item</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphItemImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getGraphItem()
+		 * @generated
+		 */
+		EClass GRAPH_ITEM = eINSTANCE.getGraphItem();
+
+		/**
+		 * The meta object literal for the '<em><b>Inherited</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GRAPH_ITEM__INHERITED = eINSTANCE.getGraphItem_Inherited();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl <em>Node</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getNode()
+		 * @generated
+		 */
+		EClass NODE = eINSTANCE.getNode();
+
+		/**
+		 * The meta object literal for the '<em><b>Graph</b></em>' container reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__GRAPH = eINSTANCE.getNode_Graph();
+
+		/**
+		 * The meta object literal for the '<em><b>Subgraph</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__SUBGRAPH = eINSTANCE.getNode_Subgraph();
+
+		/**
+		 * The meta object literal for the '<em><b>Outgoing</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__OUTGOING = eINSTANCE.getNode_Outgoing();
+
+		/**
+		 * The meta object literal for the '<em><b>Incoming</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__INCOMING = eINSTANCE.getNode_Incoming();
+
+		/**
+		 * The meta object literal for the '<em><b>State Graph Node</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__STATE_GRAPH_NODE = eINSTANCE.getNode_StateGraphNode();
+
+		/**
+		 * The meta object literal for the '<em><b>Caught Triggers</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference NODE__CAUGHT_TRIGGERS = eINSTANCE.getNode_CaughtTriggers();
+
+		/**
+		 * The meta object literal for the '<em><b>Inheritance Level</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute NODE__INHERITANCE_LEVEL = eINSTANCE.getNode_InheritanceLevel();
+
+		/**
+		 * The meta object literal for the '<em><b>To String</b></em>' operation.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EOperation NODE___TO_STRING = eINSTANCE.getNode__ToString();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl <em>Link</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getLink()
+		 * @generated
+		 */
+		EClass LINK = eINSTANCE.getLink();
+
+		/**
+		 * The meta object literal for the '<em><b>Graph</b></em>' container reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__GRAPH = eINSTANCE.getLink_Graph();
+
+		/**
+		 * The meta object literal for the '<em><b>Source</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__SOURCE = eINSTANCE.getLink_Source();
+
+		/**
+		 * The meta object literal for the '<em><b>Target</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__TARGET = eINSTANCE.getLink_Target();
+
+		/**
+		 * The meta object literal for the '<em><b>Chain Heads</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__CHAIN_HEADS = eINSTANCE.getLink_ChainHeads();
+
+		/**
+		 * The meta object literal for the '<em><b>Ifitem Triggered</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute LINK__IFITEM_TRIGGERED = eINSTANCE.getLink_IfitemTriggered();
+
+		/**
+		 * The meta object literal for the '<em><b>Common Data</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__COMMON_DATA = eINSTANCE.getLink_CommonData();
+
+		/**
+		 * The meta object literal for the '<em><b>Transition</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference LINK__TRANSITION = eINSTANCE.getLink_Transition();
+
+		/**
+		 * The meta object literal for the '<em><b>To String</b></em>' operation.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EOperation LINK___TO_STRING = eINSTANCE.getLink__ToString();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl <em>Common Trigger</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getCommonTrigger()
+		 * @generated
+		 */
+		EClass COMMON_TRIGGER = eINSTANCE.getCommonTrigger();
+
+		/**
+		 * The meta object literal for the '<em><b>Msg</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference COMMON_TRIGGER__MSG = eINSTANCE.getCommonTrigger_Msg();
+
+		/**
+		 * The meta object literal for the '<em><b>Ifitem</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference COMMON_TRIGGER__IFITEM = eINSTANCE.getCommonTrigger_Ifitem();
+
+		/**
+		 * The meta object literal for the '<em><b>Trigger</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute COMMON_TRIGGER__TRIGGER = eINSTANCE.getCommonTrigger_Trigger();
+
+		/**
+		 * The meta object literal for the '<em><b>Links</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference COMMON_TRIGGER__LINKS = eINSTANCE.getCommonTrigger_Links();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FSMGenElementImpl <em>FSM Gen Element</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FSMGenElementImpl
+		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getFSMGenElement()
+		 * @generated
+		 */
+		EClass FSM_GEN_ELEMENT = eINSTANCE.getFSMGenElement();
+
+		/**
+		 * The meta object literal for the '<em><b>Has Guard</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute COMMON_TRIGGER__HAS_GUARD = eINSTANCE.getCommonTrigger_HasGuard();
+
+	}
+
+} //FsmGenPackage
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Graph.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Graph.java
new file mode 100644
index 000000000..81760bb60
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Graph.java
@@ -0,0 +1,126 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Graph</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNodes <em>Nodes</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getLinks <em>Links</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getStateGraph <em>State Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode <em>Node</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraph()
+ * @model
+ * @generated
+ */
+public interface Graph extends FSMGenElement {
+	/**
+	 * Returns the value of the '<em><b>Nodes</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node}.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Nodes</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Nodes</em>' containment reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraph_Nodes()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph
+	 * @model opposite="graph" containment="true"
+	 * @generated
+	 */
+	EList<Node> getNodes();
+
+	/**
+	 * Returns the value of the '<em><b>Links</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link}.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph <em>Graph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Links</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Links</em>' containment reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraph_Links()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph
+	 * @model opposite="graph" containment="true"
+	 * @generated
+	 */
+	EList<Link> getLinks();
+
+	/**
+	 * Returns the value of the '<em><b>State Graph</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>State Graph</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>State Graph</em>' reference.
+	 * @see #setStateGraph(StateGraph)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraph_StateGraph()
+	 * @model
+	 * @generated
+	 */
+	StateGraph getStateGraph();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getStateGraph <em>State Graph</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>State Graph</em>' reference.
+	 * @see #getStateGraph()
+	 * @generated
+	 */
+	void setStateGraph(StateGraph value);
+
+	/**
+	 * Returns the value of the '<em><b>Node</b></em>' container reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph <em>Subgraph</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Node</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Node</em>' container reference.
+	 * @see #setNode(Node)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraph_Node()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph
+	 * @model opposite="subgraph" transient="false"
+	 * @generated
+	 */
+	Node getNode();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode <em>Node</em>}' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Node</em>' container reference.
+	 * @see #getNode()
+	 * @generated
+	 */
+	void setNode(Node value);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @model annotation="http://www.eclipse.org/emf/2002/GenModel body='StringBuilder result = new StringBuilder();\r\nresult.append(\"StateGraph {\\n\");\r\nfor (Node n : getNodes()) {\r\n\tresult.append(\"  \" + n.toString() + \"\\n\");\r\n}\r\nfor (Link l : getLinks()) {\r\n\tresult.append(\"  \" + l.toString() + \"\\n\");\r\n}\r\nresult.append(\"}\");\r\nreturn result.toString();'"
+	 * @generated
+	 */
+	String toString();
+
+} // Graph
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphContainer.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphContainer.java
new file mode 100644
index 000000000..8f1f699d0
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphContainer.java
@@ -0,0 +1,158 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Graph Container</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getComponent <em>Component</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedTriggersInStates <em>Initialized Triggers In States</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedChainHeads <em>Initialized Chain Heads</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedCommonData <em>Initialized Common Data</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer()
+ * @model
+ * @generated
+ */
+public interface GraphContainer extends FSMGenElement {
+	/**
+	 * Returns the value of the '<em><b>Graph</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Graph</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Graph</em>' containment reference.
+	 * @see #setGraph(Graph)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer_Graph()
+	 * @model containment="true"
+	 * @generated
+	 */
+	Graph getGraph();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getGraph <em>Graph</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Graph</em>' containment reference.
+	 * @see #getGraph()
+	 * @generated
+	 */
+	void setGraph(Graph value);
+
+	/**
+	 * Returns the value of the '<em><b>Component</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Component</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Component</em>' reference.
+	 * @see #setComponent(ModelComponent)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer_Component()
+	 * @model
+	 * @generated
+	 */
+	ModelComponent getComponent();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#getComponent <em>Component</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Component</em>' reference.
+	 * @see #getComponent()
+	 * @generated
+	 */
+	void setComponent(ModelComponent value);
+
+	/**
+	 * Returns the value of the '<em><b>Initialized Triggers In States</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Initialized Triggers In States</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Initialized Triggers In States</em>' attribute.
+	 * @see #setInitializedTriggersInStates(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer_InitializedTriggersInStates()
+	 * @model
+	 * @generated
+	 */
+	boolean isInitializedTriggersInStates();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedTriggersInStates <em>Initialized Triggers In States</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Initialized Triggers In States</em>' attribute.
+	 * @see #isInitializedTriggersInStates()
+	 * @generated
+	 */
+	void setInitializedTriggersInStates(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Initialized Chain Heads</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Initialized Chain Heads</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Initialized Chain Heads</em>' attribute.
+	 * @see #setInitializedChainHeads(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer_InitializedChainHeads()
+	 * @model
+	 * @generated
+	 */
+	boolean isInitializedChainHeads();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedChainHeads <em>Initialized Chain Heads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Initialized Chain Heads</em>' attribute.
+	 * @see #isInitializedChainHeads()
+	 * @generated
+	 */
+	void setInitializedChainHeads(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Initialized Common Data</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Initialized Common Data</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Initialized Common Data</em>' attribute.
+	 * @see #setInitializedCommonData(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphContainer_InitializedCommonData()
+	 * @model
+	 * @generated
+	 */
+	boolean isInitializedCommonData();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer#isInitializedCommonData <em>Initialized Common Data</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Initialized Common Data</em>' attribute.
+	 * @see #isInitializedCommonData()
+	 * @generated
+	 */
+	void setInitializedCommonData(boolean value);
+
+} // GraphContainer
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphItem.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphItem.java
new file mode 100644
index 000000000..83f2d32e2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/GraphItem.java
@@ -0,0 +1,49 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Graph Item</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem#isInherited <em>Inherited</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphItem()
+ * @model
+ * @generated
+ */
+public interface GraphItem extends FSMGenElement {
+	/**
+	 * Returns the value of the '<em><b>Inherited</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Inherited</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Inherited</em>' attribute.
+	 * @see #setInherited(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getGraphItem_Inherited()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isInherited();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem#isInherited <em>Inherited</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Inherited</em>' attribute.
+	 * @see #isInherited()
+	 * @generated
+	 */
+	void setInherited(boolean value);
+
+} // GraphItem
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Link.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Link.java
new file mode 100644
index 000000000..bbceb1278
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Link.java
@@ -0,0 +1,219 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Link</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource <em>Source</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getChainHeads <em>Chain Heads</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#isIfitemTriggered <em>Ifitem Triggered</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getCommonData <em>Common Data</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTransition <em>Transition</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink()
+ * @model
+ * @generated
+ */
+public interface Link extends GraphItem {
+	/**
+	 * Returns the value of the '<em><b>Graph</b></em>' container reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getLinks <em>Links</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Graph</em>' container reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Graph</em>' container reference.
+	 * @see #setGraph(Graph)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_Graph()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getLinks
+	 * @model opposite="links" transient="false"
+	 * @generated
+	 */
+	Graph getGraph();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getGraph <em>Graph</em>}' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Graph</em>' container reference.
+	 * @see #getGraph()
+	 * @generated
+	 */
+	void setGraph(Graph value);
+
+	/**
+	 * Returns the value of the '<em><b>Source</b></em>' reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getOutgoing <em>Outgoing</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Source</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Source</em>' reference.
+	 * @see #setSource(Node)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_Source()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getOutgoing
+	 * @model opposite="outgoing"
+	 * @generated
+	 */
+	Node getSource();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource <em>Source</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Source</em>' reference.
+	 * @see #getSource()
+	 * @generated
+	 */
+	void setSource(Node value);
+
+	/**
+	 * Returns the value of the '<em><b>Target</b></em>' reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getIncoming <em>Incoming</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Target</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Target</em>' reference.
+	 * @see #setTarget(Node)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_Target()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getIncoming
+	 * @model opposite="incoming"
+	 * @generated
+	 */
+	Node getTarget();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Target</em>' reference.
+	 * @see #getTarget()
+	 * @generated
+	 */
+	void setTarget(Node value);
+
+	/**
+	 * Returns the value of the '<em><b>Chain Heads</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Chain Heads</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Chain Heads</em>' reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_ChainHeads()
+	 * @model
+	 * @generated
+	 */
+	EList<Link> getChainHeads();
+
+	/**
+	 * Returns the value of the '<em><b>Ifitem Triggered</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Ifitem Triggered</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Ifitem Triggered</em>' attribute.
+	 * @see #setIfitemTriggered(boolean)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_IfitemTriggered()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isIfitemTriggered();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#isIfitemTriggered <em>Ifitem Triggered</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Ifitem Triggered</em>' attribute.
+	 * @see #isIfitemTriggered()
+	 * @generated
+	 */
+	void setIfitemTriggered(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Common Data</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Common Data</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Common Data</em>' reference.
+	 * @see #setCommonData(EObject)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_CommonData()
+	 * @model
+	 * @generated
+	 */
+	EObject getCommonData();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getCommonData <em>Common Data</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Common Data</em>' reference.
+	 * @see #getCommonData()
+	 * @generated
+	 */
+	void setCommonData(EObject value);
+
+	/**
+	 * Returns the value of the '<em><b>Transition</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Transition</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Transition</em>' reference.
+	 * @see #setTransition(TransitionBase)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getLink_Transition()
+	 * @model
+	 * @generated
+	 */
+	TransitionBase getTransition();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTransition <em>Transition</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Transition</em>' reference.
+	 * @see #getTransition()
+	 * @generated
+	 */
+	void setTransition(TransitionBase value);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @model annotation="http://www.eclipse.org/emf/2002/GenModel body='if (getTransition() instanceof <%org.eclipse.etrice.core.fsm.fSM.InitialTransition%>) {\r\n\treturn \"Link initial -> \" + getTarget().toString() + \" (InitialTransition)\";\r\n}\r\nelse if (getTransition() instanceof <%org.eclipse.etrice.core.fsm.fSM.NonInitialTransition%>) {\r\n\treturn \"Link \" + getSource().toString() + \" -> \" + getTarget().toString() + \" (InitialTransition)\";\r\n}\r\nelse if (getTransition() instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>) {\r\n\treturn \"RefinedTransition\";\r\n}\r\nreturn \"?\";'"
+	 * @generated
+	 */
+	String toString();
+
+} // Link
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Node.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Node.java
new file mode 100644
index 000000000..3b0530b00
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/Node.java
@@ -0,0 +1,200 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Node</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph <em>Subgraph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getOutgoing <em>Outgoing</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getIncoming <em>Incoming</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getStateGraphNode <em>State Graph Node</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getCaughtTriggers <em>Caught Triggers</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getInheritanceLevel <em>Inheritance Level</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode()
+ * @model
+ * @generated
+ */
+public interface Node extends GraphItem {
+	/**
+	 * Returns the value of the '<em><b>Graph</b></em>' container reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNodes <em>Nodes</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Graph</em>' container reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Graph</em>' container reference.
+	 * @see #setGraph(Graph)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_Graph()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNodes
+	 * @model opposite="nodes" transient="false"
+	 * @generated
+	 */
+	Graph getGraph();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getGraph <em>Graph</em>}' container reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Graph</em>' container reference.
+	 * @see #getGraph()
+	 * @generated
+	 */
+	void setGraph(Graph value);
+
+	/**
+	 * Returns the value of the '<em><b>Subgraph</b></em>' containment reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode <em>Node</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Subgraph</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Subgraph</em>' containment reference.
+	 * @see #setSubgraph(Graph)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_Subgraph()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph#getNode
+	 * @model opposite="node" containment="true"
+	 * @generated
+	 */
+	Graph getSubgraph();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getSubgraph <em>Subgraph</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Subgraph</em>' containment reference.
+	 * @see #getSubgraph()
+	 * @generated
+	 */
+	void setSubgraph(Graph value);
+
+	/**
+	 * Returns the value of the '<em><b>Outgoing</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link}.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource <em>Source</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Outgoing</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Outgoing</em>' reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_Outgoing()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getSource
+	 * @model opposite="source"
+	 * @generated
+	 */
+	EList<Link> getOutgoing();
+
+	/**
+	 * Returns the value of the '<em><b>Incoming</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link}.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Incoming</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Incoming</em>' reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_Incoming()
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link#getTarget
+	 * @model opposite="target"
+	 * @generated
+	 */
+	EList<Link> getIncoming();
+
+	/**
+	 * Returns the value of the '<em><b>State Graph Node</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>State Graph Node</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>State Graph Node</em>' reference.
+	 * @see #setStateGraphNode(StateGraphNode)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_StateGraphNode()
+	 * @model
+	 * @generated
+	 */
+	StateGraphNode getStateGraphNode();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getStateGraphNode <em>State Graph Node</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>State Graph Node</em>' reference.
+	 * @see #getStateGraphNode()
+	 * @generated
+	 */
+	void setStateGraphNode(StateGraphNode value);
+
+	/**
+	 * Returns the value of the '<em><b>Caught Triggers</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Caught Triggers</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Caught Triggers</em>' containment reference list.
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_CaughtTriggers()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CommonTrigger> getCaughtTriggers();
+
+	/**
+	 * Returns the value of the '<em><b>Inheritance Level</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Inheritance Level</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Inheritance Level</em>' attribute.
+	 * @see #setInheritanceLevel(int)
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getNode_InheritanceLevel()
+	 * @model
+	 * @generated
+	 */
+	int getInheritanceLevel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node#getInheritanceLevel <em>Inheritance Level</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Inheritance Level</em>' attribute.
+	 * @see #getInheritanceLevel()
+	 * @generated
+	 */
+	void setInheritanceLevel(int value);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @model annotation="http://www.eclipse.org/emf/2002/GenModel body='String type = \"?\";\r\nif (getStateGraphNode() instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedState%>) {\r\n\ttype = \"RefinedState\";\r\n}\r\nelse if (getStateGraphNode() instanceof <%org.eclipse.etrice.core.fsm.fSM.SimpleState%>) {\r\n\ttype = \"SimpleState\";\r\n}\r\nelse if (getStateGraphNode() instanceof <%org.eclipse.etrice.core.fsm.fSM.TrPoint%>) {\r\n\ttype = \"TrPoint\";\r\n}\r\nelse if (getStateGraphNode() instanceof <%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>) {\r\n\ttype = \"ChoicePoint\";\r\n}\r\nreturn \"Node \" + getStateGraphNode().getName() + \" (\" + type + \")\";'"
+	 * @generated
+	 */
+	String toString();
+
+} // Node
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ActiveTriggerImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/CommonTriggerImpl.java
index 3757729c1..cf7e61ca7 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ActiveTriggerImpl.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/CommonTriggerImpl.java
@@ -1,48 +1,43 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
+/**
+ */
 package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
 
 import java.util.Collection;
+
 import org.eclipse.emf.common.notify.Notification;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
 import org.eclipse.emf.ecore.util.EObjectResolvingEList;
+
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
 import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
 
 /**
  * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Active Trigger</b></em>'.
+ * An implementation of the model object '<em><b>Common Trigger</b></em>'.
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl#getMsg <em>Msg</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl#getIfitem <em>Ifitem</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl#getTrigger <em>Trigger</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl#getTransitions <em>Transitions</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl#getMsg <em>Msg</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl#getIfitem <em>Ifitem</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl#isHasGuard <em>Has Guard</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl#getTrigger <em>Trigger</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.CommonTriggerImpl#getLinks <em>Links</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
-public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements ActiveTrigger {
+public class CommonTriggerImpl extends FSMGenElementImpl implements CommonTrigger {
 	/**
 	 * The cached value of the '{@link #getMsg() <em>Msg</em>}' reference.
 	 * <!-- begin-user-doc -->
@@ -64,6 +59,26 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	protected AbstractInterfaceItem ifitem;
 
 	/**
+	 * The default value of the '{@link #isHasGuard() <em>Has Guard</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHasGuard()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HAS_GUARD_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isHasGuard() <em>Has Guard</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHasGuard()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean hasGuard = HAS_GUARD_EDEFAULT;
+
+	/**
 	 * The default value of the '{@link #getTrigger() <em>Trigger</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -84,21 +99,21 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	protected String trigger = TRIGGER_EDEFAULT;
 
 	/**
-	 * The cached value of the '{@link #getTransitions() <em>Transitions</em>}' reference list.
+	 * The cached value of the '{@link #getLinks() <em>Links</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @see #getTransitions()
+	 * @see #getLinks()
 	 * @generated
 	 * @ordered
 	 */
-	protected EList<TriggeredTransition> transitions;
+	protected EList<Link> links;
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	protected ActiveTriggerImpl() {
+	protected CommonTriggerImpl() {
 		super();
 	}
 
@@ -109,7 +124,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	 */
 	@Override
 	protected EClass eStaticClass() {
-		return FsmGenPackage.Literals.ACTIVE_TRIGGER;
+		return FsmGenPackage.Literals.COMMON_TRIGGER;
 	}
 
 	/**
@@ -123,7 +138,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 			msg = eResolveProxy(oldMsg);
 			if (msg != oldMsg) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.ACTIVE_TRIGGER__MSG, oldMsg, msg));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.COMMON_TRIGGER__MSG, oldMsg, msg));
 			}
 		}
 		return msg;
@@ -147,7 +162,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 		EObject oldMsg = msg;
 		msg = newMsg;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.ACTIVE_TRIGGER__MSG, oldMsg, msg));
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.COMMON_TRIGGER__MSG, oldMsg, msg));
 	}
 
 	/**
@@ -161,7 +176,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 			ifitem = (AbstractInterfaceItem)eResolveProxy(oldIfitem);
 			if (ifitem != oldIfitem) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.ACTIVE_TRIGGER__IFITEM, oldIfitem, ifitem));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.COMMON_TRIGGER__IFITEM, oldIfitem, ifitem));
 			}
 		}
 		return ifitem;
@@ -185,7 +200,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 		AbstractInterfaceItem oldIfitem = ifitem;
 		ifitem = newIfitem;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.ACTIVE_TRIGGER__IFITEM, oldIfitem, ifitem));
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.COMMON_TRIGGER__IFITEM, oldIfitem, ifitem));
 	}
 
 	/**
@@ -206,7 +221,7 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 		String oldTrigger = trigger;
 		trigger = newTrigger;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.ACTIVE_TRIGGER__TRIGGER, oldTrigger, trigger));
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.COMMON_TRIGGER__TRIGGER, oldTrigger, trigger));
 	}
 
 	/**
@@ -214,11 +229,32 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public EList<TriggeredTransition> getTransitions() {
-		if (transitions == null) {
-			transitions = new EObjectResolvingEList<TriggeredTransition>(TriggeredTransition.class, this, FsmGenPackage.ACTIVE_TRIGGER__TRANSITIONS);
+	public EList<Link> getLinks() {
+		if (links == null) {
+			links = new EObjectResolvingEList<Link>(Link.class, this, FsmGenPackage.COMMON_TRIGGER__LINKS);
 		}
-		return transitions;
+		return links;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isHasGuard() {
+		return hasGuard;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setHasGuard(boolean newHasGuard) {
+		boolean oldHasGuard = hasGuard;
+		hasGuard = newHasGuard;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.COMMON_TRIGGER__HAS_GUARD, oldHasGuard, hasGuard));
 	}
 
 	/**
@@ -229,16 +265,18 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case FsmGenPackage.ACTIVE_TRIGGER__MSG:
+			case FsmGenPackage.COMMON_TRIGGER__MSG:
 				if (resolve) return getMsg();
 				return basicGetMsg();
-			case FsmGenPackage.ACTIVE_TRIGGER__IFITEM:
+			case FsmGenPackage.COMMON_TRIGGER__IFITEM:
 				if (resolve) return getIfitem();
 				return basicGetIfitem();
-			case FsmGenPackage.ACTIVE_TRIGGER__TRIGGER:
+			case FsmGenPackage.COMMON_TRIGGER__HAS_GUARD:
+				return isHasGuard();
+			case FsmGenPackage.COMMON_TRIGGER__TRIGGER:
 				return getTrigger();
-			case FsmGenPackage.ACTIVE_TRIGGER__TRANSITIONS:
-				return getTransitions();
+			case FsmGenPackage.COMMON_TRIGGER__LINKS:
+				return getLinks();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -252,18 +290,21 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case FsmGenPackage.ACTIVE_TRIGGER__MSG:
+			case FsmGenPackage.COMMON_TRIGGER__MSG:
 				setMsg((EObject)newValue);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__IFITEM:
+			case FsmGenPackage.COMMON_TRIGGER__IFITEM:
 				setIfitem((AbstractInterfaceItem)newValue);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__TRIGGER:
+			case FsmGenPackage.COMMON_TRIGGER__HAS_GUARD:
+				setHasGuard((Boolean)newValue);
+				return;
+			case FsmGenPackage.COMMON_TRIGGER__TRIGGER:
 				setTrigger((String)newValue);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__TRANSITIONS:
-				getTransitions().clear();
-				getTransitions().addAll((Collection<? extends TriggeredTransition>)newValue);
+			case FsmGenPackage.COMMON_TRIGGER__LINKS:
+				getLinks().clear();
+				getLinks().addAll((Collection<? extends Link>)newValue);
 				return;
 		}
 		super.eSet(featureID, newValue);
@@ -277,17 +318,20 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case FsmGenPackage.ACTIVE_TRIGGER__MSG:
+			case FsmGenPackage.COMMON_TRIGGER__MSG:
 				setMsg((EObject)null);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__IFITEM:
+			case FsmGenPackage.COMMON_TRIGGER__IFITEM:
 				setIfitem((AbstractInterfaceItem)null);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__TRIGGER:
+			case FsmGenPackage.COMMON_TRIGGER__HAS_GUARD:
+				setHasGuard(HAS_GUARD_EDEFAULT);
+				return;
+			case FsmGenPackage.COMMON_TRIGGER__TRIGGER:
 				setTrigger(TRIGGER_EDEFAULT);
 				return;
-			case FsmGenPackage.ACTIVE_TRIGGER__TRANSITIONS:
-				getTransitions().clear();
+			case FsmGenPackage.COMMON_TRIGGER__LINKS:
+				getLinks().clear();
 				return;
 		}
 		super.eUnset(featureID);
@@ -301,14 +345,16 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case FsmGenPackage.ACTIVE_TRIGGER__MSG:
+			case FsmGenPackage.COMMON_TRIGGER__MSG:
 				return msg != null;
-			case FsmGenPackage.ACTIVE_TRIGGER__IFITEM:
+			case FsmGenPackage.COMMON_TRIGGER__IFITEM:
 				return ifitem != null;
-			case FsmGenPackage.ACTIVE_TRIGGER__TRIGGER:
+			case FsmGenPackage.COMMON_TRIGGER__HAS_GUARD:
+				return hasGuard != HAS_GUARD_EDEFAULT;
+			case FsmGenPackage.COMMON_TRIGGER__TRIGGER:
 				return TRIGGER_EDEFAULT == null ? trigger != null : !TRIGGER_EDEFAULT.equals(trigger);
-			case FsmGenPackage.ACTIVE_TRIGGER__TRANSITIONS:
-				return transitions != null && !transitions.isEmpty();
+			case FsmGenPackage.COMMON_TRIGGER__LINKS:
+				return links != null && !links.isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
@@ -323,10 +369,12 @@ public class ActiveTriggerImpl extends MinimalEObjectImpl.Container implements A
 		if (eIsProxy()) return super.toString();
 
 		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (trigger: ");
+		result.append(" (hasGuard: ");
+		result.append(hasGuard);
+		result.append(", trigger: ");
 		result.append(trigger);
 		result.append(')');
 		return result.toString();
 	}
 
-} //ActiveTriggerImpl
+} //CommonTriggerImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FSMGenElementImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FSMGenElementImpl.java
new file mode 100644
index 000000000..4fb50270e
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FSMGenElementImpl.java
@@ -0,0 +1,39 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>FSM Gen Element</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class FSMGenElementImpl extends MinimalEObjectImpl.Container implements FSMGenElement {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected FSMGenElementImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.FSM_GEN_ELEMENT;
+	}
+
+} //FSMGenElementImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenFactoryImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenFactoryImpl.java
index 7d585d39d..32092c0b0 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenFactoryImpl.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenFactoryImpl.java
@@ -1,13 +1,4 @@
 /**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
  */
 package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
 
@@ -65,10 +56,13 @@ public class FsmGenFactoryImpl extends EFactoryImpl implements FsmGenFactory {
 	@Override
 	public EObject create(EClass eClass) {
 		switch (eClass.getClassifierID()) {
-			case FsmGenPackage.ACTIVE_TRIGGER: return createActiveTrigger();
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT: return createExpandedModelComponent();
-			case FsmGenPackage.EXPANDED_REFINED_STATE: return createExpandedRefinedState();
-			case FsmGenPackage.TRANSITION_CHAIN: return createTransitionChain();
+			case FsmGenPackage.GRAPH_CONTAINER: return createGraphContainer();
+			case FsmGenPackage.GRAPH: return createGraph();
+			case FsmGenPackage.GRAPH_ITEM: return createGraphItem();
+			case FsmGenPackage.NODE: return createNode();
+			case FsmGenPackage.LINK: return createLink();
+			case FsmGenPackage.COMMON_TRIGGER: return createCommonTrigger();
+			case FsmGenPackage.FSM_GEN_ELEMENT: return createFSMGenElement();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
@@ -79,9 +73,9 @@ public class FsmGenFactoryImpl extends EFactoryImpl implements FsmGenFactory {
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public ActiveTrigger createActiveTrigger() {
-		ActiveTriggerImpl activeTrigger = new ActiveTriggerImpl();
-		return activeTrigger;
+	public GraphContainer createGraphContainer() {
+		GraphContainerImpl graphContainer = new GraphContainerImpl();
+		return graphContainer;
 	}
 
 	/**
@@ -89,9 +83,9 @@ public class FsmGenFactoryImpl extends EFactoryImpl implements FsmGenFactory {
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public ExpandedModelComponent createExpandedModelComponent() {
-		ExpandedModelComponentImpl expandedModelComponent = new ExpandedModelComponentImpl();
-		return expandedModelComponent;
+	public Graph createGraph() {
+		GraphImpl graph = new GraphImpl();
+		return graph;
 	}
 
 	/**
@@ -99,9 +93,9 @@ public class FsmGenFactoryImpl extends EFactoryImpl implements FsmGenFactory {
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public ExpandedRefinedState createExpandedRefinedState() {
-		ExpandedRefinedStateImpl expandedRefinedState = new ExpandedRefinedStateImpl();
-		return expandedRefinedState;
+	public GraphItem createGraphItem() {
+		GraphItemImpl graphItem = new GraphItemImpl();
+		return graphItem;
 	}
 
 	/**
@@ -109,9 +103,39 @@ public class FsmGenFactoryImpl extends EFactoryImpl implements FsmGenFactory {
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	public TransitionChain createTransitionChain() {
-		TransitionChainImpl transitionChain = new TransitionChainImpl();
-		return transitionChain;
+	public Node createNode() {
+		NodeImpl node = new NodeImpl();
+		return node;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Link createLink() {
+		LinkImpl link = new LinkImpl();
+		return link;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CommonTrigger createCommonTrigger() {
+		CommonTriggerImpl commonTrigger = new CommonTriggerImpl();
+		return commonTrigger;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public FSMGenElement createFSMGenElement() {
+		FSMGenElementImpl fsmGenElement = new FSMGenElementImpl();
+		return fsmGenElement;
 	}
 
 	/**
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java
new file mode 100644
index 000000000..e20daf7a2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java
@@ -0,0 +1,663 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EOperation;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
+
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class FsmGenPackageImpl extends EPackageImpl implements FsmGenPackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass graphContainerEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass graphEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass graphItemEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass nodeEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass linkEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass commonTriggerEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass fsmGenElementEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private FsmGenPackageImpl() {
+		super(eNS_URI, FsmGenFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 * 
+	 * <p>This method is used to initialize {@link FsmGenPackage#eINSTANCE} when that field is accessed.
+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static FsmGenPackage init() {
+		if (isInited) return (FsmGenPackage)EPackage.Registry.INSTANCE.getEPackage(FsmGenPackage.eNS_URI);
+
+		// Obtain or create and register package
+		FsmGenPackageImpl theFsmGenPackage = (FsmGenPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof FsmGenPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new FsmGenPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		FSMPackage.eINSTANCE.eClass();
+
+		// Create package meta-data objects
+		theFsmGenPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theFsmGenPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theFsmGenPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(FsmGenPackage.eNS_URI, theFsmGenPackage);
+		return theFsmGenPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getGraphContainer() {
+		return graphContainerEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraphContainer_Graph() {
+		return (EReference)graphContainerEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraphContainer_Component() {
+		return (EReference)graphContainerEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getGraphContainer_InitializedTriggersInStates() {
+		return (EAttribute)graphContainerEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getGraphContainer_InitializedChainHeads() {
+		return (EAttribute)graphContainerEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getGraphContainer_InitializedCommonData() {
+		return (EAttribute)graphContainerEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getGraph() {
+		return graphEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraph_Nodes() {
+		return (EReference)graphEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraph_Links() {
+		return (EReference)graphEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraph_StateGraph() {
+		return (EReference)graphEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getGraph_Node() {
+		return (EReference)graphEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EOperation getGraph__ToString() {
+		return graphEClass.getEOperations().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getGraphItem() {
+		return graphItemEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getGraphItem_Inherited() {
+		return (EAttribute)graphItemEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getNode() {
+		return nodeEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_Graph() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_Subgraph() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_Outgoing() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_Incoming() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_StateGraphNode() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getNode_CaughtTriggers() {
+		return (EReference)nodeEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getNode_InheritanceLevel() {
+		return (EAttribute)nodeEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EOperation getNode__ToString() {
+		return nodeEClass.getEOperations().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getLink() {
+		return linkEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_Graph() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_Source() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_Target() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_ChainHeads() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getLink_IfitemTriggered() {
+		return (EAttribute)linkEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_CommonData() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getLink_Transition() {
+		return (EReference)linkEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EOperation getLink__ToString() {
+		return linkEClass.getEOperations().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getCommonTrigger() {
+		return commonTriggerEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getCommonTrigger_Msg() {
+		return (EReference)commonTriggerEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getCommonTrigger_Ifitem() {
+		return (EReference)commonTriggerEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getCommonTrigger_Trigger() {
+		return (EAttribute)commonTriggerEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getCommonTrigger_Links() {
+		return (EReference)commonTriggerEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getFSMGenElement() {
+		return fsmGenElementEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getCommonTrigger_HasGuard() {
+		return (EAttribute)commonTriggerEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public FsmGenFactory getFsmGenFactory() {
+		return (FsmGenFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		graphContainerEClass = createEClass(GRAPH_CONTAINER);
+		createEReference(graphContainerEClass, GRAPH_CONTAINER__GRAPH);
+		createEReference(graphContainerEClass, GRAPH_CONTAINER__COMPONENT);
+		createEAttribute(graphContainerEClass, GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES);
+		createEAttribute(graphContainerEClass, GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS);
+		createEAttribute(graphContainerEClass, GRAPH_CONTAINER__INITIALIZED_COMMON_DATA);
+
+		graphEClass = createEClass(GRAPH);
+		createEReference(graphEClass, GRAPH__NODES);
+		createEReference(graphEClass, GRAPH__LINKS);
+		createEReference(graphEClass, GRAPH__STATE_GRAPH);
+		createEReference(graphEClass, GRAPH__NODE);
+		createEOperation(graphEClass, GRAPH___TO_STRING);
+
+		graphItemEClass = createEClass(GRAPH_ITEM);
+		createEAttribute(graphItemEClass, GRAPH_ITEM__INHERITED);
+
+		nodeEClass = createEClass(NODE);
+		createEReference(nodeEClass, NODE__GRAPH);
+		createEReference(nodeEClass, NODE__SUBGRAPH);
+		createEReference(nodeEClass, NODE__OUTGOING);
+		createEReference(nodeEClass, NODE__INCOMING);
+		createEReference(nodeEClass, NODE__STATE_GRAPH_NODE);
+		createEReference(nodeEClass, NODE__CAUGHT_TRIGGERS);
+		createEAttribute(nodeEClass, NODE__INHERITANCE_LEVEL);
+		createEOperation(nodeEClass, NODE___TO_STRING);
+
+		linkEClass = createEClass(LINK);
+		createEReference(linkEClass, LINK__GRAPH);
+		createEReference(linkEClass, LINK__SOURCE);
+		createEReference(linkEClass, LINK__TARGET);
+		createEReference(linkEClass, LINK__CHAIN_HEADS);
+		createEAttribute(linkEClass, LINK__IFITEM_TRIGGERED);
+		createEReference(linkEClass, LINK__COMMON_DATA);
+		createEReference(linkEClass, LINK__TRANSITION);
+		createEOperation(linkEClass, LINK___TO_STRING);
+
+		commonTriggerEClass = createEClass(COMMON_TRIGGER);
+		createEReference(commonTriggerEClass, COMMON_TRIGGER__MSG);
+		createEReference(commonTriggerEClass, COMMON_TRIGGER__IFITEM);
+		createEAttribute(commonTriggerEClass, COMMON_TRIGGER__HAS_GUARD);
+		createEAttribute(commonTriggerEClass, COMMON_TRIGGER__TRIGGER);
+		createEReference(commonTriggerEClass, COMMON_TRIGGER__LINKS);
+
+		fsmGenElementEClass = createEClass(FSM_GEN_ELEMENT);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		FSMPackage theFSMPackage = (FSMPackage)EPackage.Registry.INSTANCE.getEPackage(FSMPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		graphContainerEClass.getESuperTypes().add(this.getFSMGenElement());
+		graphEClass.getESuperTypes().add(this.getFSMGenElement());
+		graphItemEClass.getESuperTypes().add(this.getFSMGenElement());
+		nodeEClass.getESuperTypes().add(this.getGraphItem());
+		linkEClass.getESuperTypes().add(this.getGraphItem());
+		commonTriggerEClass.getESuperTypes().add(this.getFSMGenElement());
+
+		// Initialize classes, features, and operations; add parameters
+		initEClass(graphContainerEClass, GraphContainer.class, "GraphContainer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getGraphContainer_Graph(), this.getGraph(), null, "graph", null, 0, 1, GraphContainer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getGraphContainer_Component(), theFSMPackage.getModelComponent(), null, "component", null, 0, 1, GraphContainer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getGraphContainer_InitializedTriggersInStates(), ecorePackage.getEBoolean(), "initializedTriggersInStates", null, 0, 1, GraphContainer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getGraphContainer_InitializedChainHeads(), ecorePackage.getEBoolean(), "initializedChainHeads", null, 0, 1, GraphContainer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getGraphContainer_InitializedCommonData(), ecorePackage.getEBoolean(), "initializedCommonData", null, 0, 1, GraphContainer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(graphEClass, Graph.class, "Graph", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getGraph_Nodes(), this.getNode(), this.getNode_Graph(), "nodes", null, 0, -1, Graph.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getGraph_Links(), this.getLink(), this.getLink_Graph(), "links", null, 0, -1, Graph.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getGraph_StateGraph(), theFSMPackage.getStateGraph(), null, "stateGraph", null, 0, 1, Graph.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getGraph_Node(), this.getNode(), this.getNode_Subgraph(), "node", null, 0, 1, Graph.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEOperation(getGraph__ToString(), ecorePackage.getEString(), "toString", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(graphItemEClass, GraphItem.class, "GraphItem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getGraphItem_Inherited(), ecorePackage.getEBoolean(), "inherited", "false", 0, 1, GraphItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(nodeEClass, Node.class, "Node", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getNode_Graph(), this.getGraph(), this.getGraph_Nodes(), "graph", null, 0, 1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getNode_Subgraph(), this.getGraph(), this.getGraph_Node(), "subgraph", null, 0, 1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getNode_Outgoing(), this.getLink(), this.getLink_Source(), "outgoing", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getNode_Incoming(), this.getLink(), this.getLink_Target(), "incoming", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getNode_StateGraphNode(), theFSMPackage.getStateGraphNode(), null, "stateGraphNode", null, 0, 1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getNode_CaughtTriggers(), this.getCommonTrigger(), null, "caughtTriggers", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getNode_InheritanceLevel(), ecorePackage.getEInt(), "inheritanceLevel", null, 0, 1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEOperation(getNode__ToString(), ecorePackage.getEString(), "toString", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(linkEClass, Link.class, "Link", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getLink_Graph(), this.getGraph(), this.getGraph_Links(), "graph", null, 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getLink_Source(), this.getNode(), this.getNode_Outgoing(), "source", null, 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getLink_Target(), this.getNode(), this.getNode_Incoming(), "target", null, 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getLink_ChainHeads(), this.getLink(), null, "chainHeads", null, 0, -1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getLink_IfitemTriggered(), ecorePackage.getEBoolean(), "ifitemTriggered", "true", 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getLink_CommonData(), ecorePackage.getEObject(), null, "commonData", null, 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getLink_Transition(), theFSMPackage.getTransitionBase(), null, "transition", null, 0, 1, Link.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEOperation(getLink__ToString(), ecorePackage.getEString(), "toString", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(commonTriggerEClass, CommonTrigger.class, "CommonTrigger", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCommonTrigger_Msg(), ecorePackage.getEObject(), null, "msg", null, 0, 1, CommonTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCommonTrigger_Ifitem(), theFSMPackage.getAbstractInterfaceItem(), null, "ifitem", null, 0, 1, CommonTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCommonTrigger_HasGuard(), ecorePackage.getEBoolean(), "hasGuard", null, 0, 1, CommonTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCommonTrigger_Trigger(), ecorePackage.getEString(), "trigger", null, 0, 1, CommonTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCommonTrigger_Links(), this.getLink(), null, "links", null, 0, -1, CommonTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(fsmGenElementEClass, FSMGenElement.class, "FSMGenElement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+} //FsmGenPackageImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphContainerImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphContainerImpl.java
new file mode 100644
index 000000000..6b2c3afdf
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphContainerImpl.java
@@ -0,0 +1,412 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Graph Container</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl#getComponent <em>Component</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl#isInitializedTriggersInStates <em>Initialized Triggers In States</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl#isInitializedChainHeads <em>Initialized Chain Heads</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphContainerImpl#isInitializedCommonData <em>Initialized Common Data</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class GraphContainerImpl extends FSMGenElementImpl implements GraphContainer {
+	/**
+	 * The cached value of the '{@link #getGraph() <em>Graph</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGraph()
+	 * @generated
+	 * @ordered
+	 */
+	protected Graph graph;
+
+	/**
+	 * The cached value of the '{@link #getComponent() <em>Component</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getComponent()
+	 * @generated
+	 * @ordered
+	 */
+	protected ModelComponent component;
+
+	/**
+	 * The default value of the '{@link #isInitializedTriggersInStates() <em>Initialized Triggers In States</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedTriggersInStates()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean INITIALIZED_TRIGGERS_IN_STATES_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isInitializedTriggersInStates() <em>Initialized Triggers In States</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedTriggersInStates()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean initializedTriggersInStates = INITIALIZED_TRIGGERS_IN_STATES_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isInitializedChainHeads() <em>Initialized Chain Heads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedChainHeads()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean INITIALIZED_CHAIN_HEADS_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isInitializedChainHeads() <em>Initialized Chain Heads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedChainHeads()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean initializedChainHeads = INITIALIZED_CHAIN_HEADS_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isInitializedCommonData() <em>Initialized Common Data</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedCommonData()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean INITIALIZED_COMMON_DATA_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isInitializedCommonData() <em>Initialized Common Data</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInitializedCommonData()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean initializedCommonData = INITIALIZED_COMMON_DATA_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected GraphContainerImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.GRAPH_CONTAINER;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Graph getGraph() {
+		return graph;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetGraph(Graph newGraph, NotificationChain msgs) {
+		Graph oldGraph = graph;
+		graph = newGraph;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__GRAPH, oldGraph, newGraph);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setGraph(Graph newGraph) {
+		if (newGraph != graph) {
+			NotificationChain msgs = null;
+			if (graph != null)
+				msgs = ((InternalEObject)graph).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.GRAPH_CONTAINER__GRAPH, null, msgs);
+			if (newGraph != null)
+				msgs = ((InternalEObject)newGraph).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.GRAPH_CONTAINER__GRAPH, null, msgs);
+			msgs = basicSetGraph(newGraph, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__GRAPH, newGraph, newGraph));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ModelComponent getComponent() {
+		if (component != null && component.eIsProxy()) {
+			InternalEObject oldComponent = (InternalEObject)component;
+			component = (ModelComponent)eResolveProxy(oldComponent);
+			if (component != oldComponent) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.GRAPH_CONTAINER__COMPONENT, oldComponent, component));
+			}
+		}
+		return component;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ModelComponent basicGetComponent() {
+		return component;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setComponent(ModelComponent newComponent) {
+		ModelComponent oldComponent = component;
+		component = newComponent;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__COMPONENT, oldComponent, component));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isInitializedTriggersInStates() {
+		return initializedTriggersInStates;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setInitializedTriggersInStates(boolean newInitializedTriggersInStates) {
+		boolean oldInitializedTriggersInStates = initializedTriggersInStates;
+		initializedTriggersInStates = newInitializedTriggersInStates;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES, oldInitializedTriggersInStates, initializedTriggersInStates));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isInitializedChainHeads() {
+		return initializedChainHeads;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setInitializedChainHeads(boolean newInitializedChainHeads) {
+		boolean oldInitializedChainHeads = initializedChainHeads;
+		initializedChainHeads = newInitializedChainHeads;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS, oldInitializedChainHeads, initializedChainHeads));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isInitializedCommonData() {
+		return initializedCommonData;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setInitializedCommonData(boolean newInitializedCommonData) {
+		boolean oldInitializedCommonData = initializedCommonData;
+		initializedCommonData = newInitializedCommonData;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_COMMON_DATA, oldInitializedCommonData, initializedCommonData));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_CONTAINER__GRAPH:
+				return basicSetGraph(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_CONTAINER__GRAPH:
+				return getGraph();
+			case FsmGenPackage.GRAPH_CONTAINER__COMPONENT:
+				if (resolve) return getComponent();
+				return basicGetComponent();
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES:
+				return isInitializedTriggersInStates();
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS:
+				return isInitializedChainHeads();
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_COMMON_DATA:
+				return isInitializedCommonData();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_CONTAINER__GRAPH:
+				setGraph((Graph)newValue);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__COMPONENT:
+				setComponent((ModelComponent)newValue);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES:
+				setInitializedTriggersInStates((Boolean)newValue);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS:
+				setInitializedChainHeads((Boolean)newValue);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_COMMON_DATA:
+				setInitializedCommonData((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_CONTAINER__GRAPH:
+				setGraph((Graph)null);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__COMPONENT:
+				setComponent((ModelComponent)null);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES:
+				setInitializedTriggersInStates(INITIALIZED_TRIGGERS_IN_STATES_EDEFAULT);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS:
+				setInitializedChainHeads(INITIALIZED_CHAIN_HEADS_EDEFAULT);
+				return;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_COMMON_DATA:
+				setInitializedCommonData(INITIALIZED_COMMON_DATA_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_CONTAINER__GRAPH:
+				return graph != null;
+			case FsmGenPackage.GRAPH_CONTAINER__COMPONENT:
+				return component != null;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_TRIGGERS_IN_STATES:
+				return initializedTriggersInStates != INITIALIZED_TRIGGERS_IN_STATES_EDEFAULT;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_CHAIN_HEADS:
+				return initializedChainHeads != INITIALIZED_CHAIN_HEADS_EDEFAULT;
+			case FsmGenPackage.GRAPH_CONTAINER__INITIALIZED_COMMON_DATA:
+				return initializedCommonData != INITIALIZED_COMMON_DATA_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (initializedTriggersInStates: ");
+		result.append(initializedTriggersInStates);
+		result.append(", initializedChainHeads: ");
+		result.append(initializedChainHeads);
+		result.append(", initializedCommonData: ");
+		result.append(initializedCommonData);
+		result.append(')');
+		return result.toString();
+	}
+
+} //GraphContainerImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphImpl.java
new file mode 100644
index 000000000..b6dadf54c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphImpl.java
@@ -0,0 +1,372 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Graph</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl#getNodes <em>Nodes</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl#getLinks <em>Links</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl#getStateGraph <em>State Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphImpl#getNode <em>Node</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class GraphImpl extends FSMGenElementImpl implements Graph {
+	/**
+	 * The cached value of the '{@link #getNodes() <em>Nodes</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNodes()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Node> nodes;
+
+	/**
+	 * The cached value of the '{@link #getLinks() <em>Links</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLinks()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Link> links;
+
+	/**
+	 * The cached value of the '{@link #getStateGraph() <em>State Graph</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getStateGraph()
+	 * @generated
+	 * @ordered
+	 */
+	protected StateGraph stateGraph;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected GraphImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.GRAPH;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Node> getNodes() {
+		if (nodes == null) {
+			nodes = new EObjectContainmentWithInverseEList<Node>(Node.class, this, FsmGenPackage.GRAPH__NODES, FsmGenPackage.NODE__GRAPH);
+		}
+		return nodes;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Link> getLinks() {
+		if (links == null) {
+			links = new EObjectContainmentWithInverseEList<Link>(Link.class, this, FsmGenPackage.GRAPH__LINKS, FsmGenPackage.LINK__GRAPH);
+		}
+		return links;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public StateGraph getStateGraph() {
+		if (stateGraph != null && stateGraph.eIsProxy()) {
+			InternalEObject oldStateGraph = (InternalEObject)stateGraph;
+			stateGraph = (StateGraph)eResolveProxy(oldStateGraph);
+			if (stateGraph != oldStateGraph) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.GRAPH__STATE_GRAPH, oldStateGraph, stateGraph));
+			}
+		}
+		return stateGraph;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public StateGraph basicGetStateGraph() {
+		return stateGraph;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setStateGraph(StateGraph newStateGraph) {
+		StateGraph oldStateGraph = stateGraph;
+		stateGraph = newStateGraph;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH__STATE_GRAPH, oldStateGraph, stateGraph));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Node getNode() {
+		if (eContainerFeatureID() != FsmGenPackage.GRAPH__NODE) return null;
+		return (Node)eInternalContainer();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetNode(Node newNode, NotificationChain msgs) {
+		msgs = eBasicSetContainer((InternalEObject)newNode, FsmGenPackage.GRAPH__NODE, msgs);
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setNode(Node newNode) {
+		if (newNode != eInternalContainer() || (eContainerFeatureID() != FsmGenPackage.GRAPH__NODE && newNode != null)) {
+			if (EcoreUtil.isAncestor(this, newNode))
+				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
+			NotificationChain msgs = null;
+			if (eInternalContainer() != null)
+				msgs = eBasicRemoveFromContainer(msgs);
+			if (newNode != null)
+				msgs = ((InternalEObject)newNode).eInverseAdd(this, FsmGenPackage.NODE__SUBGRAPH, Node.class, msgs);
+			msgs = basicSetNode(newNode, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH__NODE, newNode, newNode));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+		result.append("StateGraph {\n");
+		for (Node n : getNodes()) {
+			result.append("  " + n.toString() + "\n");
+		}
+		for (Link l : getLinks()) {
+			result.append("  " + l.toString() + "\n");
+		}
+		result.append("}");
+		return result.toString();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getNodes()).basicAdd(otherEnd, msgs);
+			case FsmGenPackage.GRAPH__LINKS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getLinks()).basicAdd(otherEnd, msgs);
+			case FsmGenPackage.GRAPH__NODE:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetNode((Node)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				return ((InternalEList<?>)getNodes()).basicRemove(otherEnd, msgs);
+			case FsmGenPackage.GRAPH__LINKS:
+				return ((InternalEList<?>)getLinks()).basicRemove(otherEnd, msgs);
+			case FsmGenPackage.GRAPH__NODE:
+				return basicSetNode(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
+		switch (eContainerFeatureID()) {
+			case FsmGenPackage.GRAPH__NODE:
+				return eInternalContainer().eInverseRemove(this, FsmGenPackage.NODE__SUBGRAPH, Node.class, msgs);
+		}
+		return super.eBasicRemoveFromContainerFeature(msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				return getNodes();
+			case FsmGenPackage.GRAPH__LINKS:
+				return getLinks();
+			case FsmGenPackage.GRAPH__STATE_GRAPH:
+				if (resolve) return getStateGraph();
+				return basicGetStateGraph();
+			case FsmGenPackage.GRAPH__NODE:
+				return getNode();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				getNodes().clear();
+				getNodes().addAll((Collection<? extends Node>)newValue);
+				return;
+			case FsmGenPackage.GRAPH__LINKS:
+				getLinks().clear();
+				getLinks().addAll((Collection<? extends Link>)newValue);
+				return;
+			case FsmGenPackage.GRAPH__STATE_GRAPH:
+				setStateGraph((StateGraph)newValue);
+				return;
+			case FsmGenPackage.GRAPH__NODE:
+				setNode((Node)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				getNodes().clear();
+				return;
+			case FsmGenPackage.GRAPH__LINKS:
+				getLinks().clear();
+				return;
+			case FsmGenPackage.GRAPH__STATE_GRAPH:
+				setStateGraph((StateGraph)null);
+				return;
+			case FsmGenPackage.GRAPH__NODE:
+				setNode((Node)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH__NODES:
+				return nodes != null && !nodes.isEmpty();
+			case FsmGenPackage.GRAPH__LINKS:
+				return links != null && !links.isEmpty();
+			case FsmGenPackage.GRAPH__STATE_GRAPH:
+				return stateGraph != null;
+			case FsmGenPackage.GRAPH__NODE:
+				return getNode() != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException {
+		switch (operationID) {
+			case FsmGenPackage.GRAPH___TO_STRING:
+				return toString();
+		}
+		return super.eInvoke(operationID, arguments);
+	}
+
+} //GraphImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphItemImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphItemImpl.java
new file mode 100644
index 000000000..239cfd8aa
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/GraphItemImpl.java
@@ -0,0 +1,161 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Graph Item</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.GraphItemImpl#isInherited <em>Inherited</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class GraphItemImpl extends FSMGenElementImpl implements GraphItem {
+	/**
+	 * The default value of the '{@link #isInherited() <em>Inherited</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInherited()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean INHERITED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isInherited() <em>Inherited</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isInherited()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean inherited = INHERITED_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected GraphItemImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.GRAPH_ITEM;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isInherited() {
+		return inherited;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setInherited(boolean newInherited) {
+		boolean oldInherited = inherited;
+		inherited = newInherited;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.GRAPH_ITEM__INHERITED, oldInherited, inherited));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_ITEM__INHERITED:
+				return isInherited();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_ITEM__INHERITED:
+				setInherited((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_ITEM__INHERITED:
+				setInherited(INHERITED_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.GRAPH_ITEM__INHERITED:
+				return inherited != INHERITED_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (inherited: ");
+		result.append(inherited);
+		result.append(')');
+		return result.toString();
+	}
+
+} //GraphItemImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/LinkImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/LinkImpl.java
new file mode 100644
index 000000000..e3190f0c8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/LinkImpl.java
@@ -0,0 +1,621 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectResolvingEList;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+
+import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Link</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getSource <em>Source</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getChainHeads <em>Chain Heads</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#isIfitemTriggered <em>Ifitem Triggered</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getCommonData <em>Common Data</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.LinkImpl#getTransition <em>Transition</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class LinkImpl extends GraphItemImpl implements Link {
+	/**
+	 * The cached value of the '{@link #getSource() <em>Source</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSource()
+	 * @generated
+	 * @ordered
+	 */
+	protected Node source;
+
+	/**
+	 * The cached value of the '{@link #getTarget() <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTarget()
+	 * @generated
+	 * @ordered
+	 */
+	protected Node target;
+
+	/**
+	 * The cached value of the '{@link #getChainHeads() <em>Chain Heads</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getChainHeads()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Link> chainHeads;
+
+	/**
+	 * The default value of the '{@link #isIfitemTriggered() <em>Ifitem Triggered</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isIfitemTriggered()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean IFITEM_TRIGGERED_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isIfitemTriggered() <em>Ifitem Triggered</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isIfitemTriggered()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean ifitemTriggered = IFITEM_TRIGGERED_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getCommonData() <em>Common Data</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCommonData()
+	 * @generated
+	 * @ordered
+	 */
+	protected EObject commonData;
+
+	/**
+	 * The cached value of the '{@link #getTransition() <em>Transition</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTransition()
+	 * @generated
+	 * @ordered
+	 */
+	protected TransitionBase transition;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected LinkImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.LINK;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Graph getGraph() {
+		if (eContainerFeatureID() != FsmGenPackage.LINK__GRAPH) return null;
+		return (Graph)eInternalContainer();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetGraph(Graph newGraph, NotificationChain msgs) {
+		msgs = eBasicSetContainer((InternalEObject)newGraph, FsmGenPackage.LINK__GRAPH, msgs);
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setGraph(Graph newGraph) {
+		if (newGraph != eInternalContainer() || (eContainerFeatureID() != FsmGenPackage.LINK__GRAPH && newGraph != null)) {
+			if (EcoreUtil.isAncestor(this, newGraph))
+				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
+			NotificationChain msgs = null;
+			if (eInternalContainer() != null)
+				msgs = eBasicRemoveFromContainer(msgs);
+			if (newGraph != null)
+				msgs = ((InternalEObject)newGraph).eInverseAdd(this, FsmGenPackage.GRAPH__LINKS, Graph.class, msgs);
+			msgs = basicSetGraph(newGraph, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__GRAPH, newGraph, newGraph));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Node getSource() {
+		if (source != null && source.eIsProxy()) {
+			InternalEObject oldSource = (InternalEObject)source;
+			source = (Node)eResolveProxy(oldSource);
+			if (source != oldSource) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.LINK__SOURCE, oldSource, source));
+			}
+		}
+		return source;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Node basicGetSource() {
+		return source;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetSource(Node newSource, NotificationChain msgs) {
+		Node oldSource = source;
+		source = newSource;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__SOURCE, oldSource, newSource);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSource(Node newSource) {
+		if (newSource != source) {
+			NotificationChain msgs = null;
+			if (source != null)
+				msgs = ((InternalEObject)source).eInverseRemove(this, FsmGenPackage.NODE__OUTGOING, Node.class, msgs);
+			if (newSource != null)
+				msgs = ((InternalEObject)newSource).eInverseAdd(this, FsmGenPackage.NODE__OUTGOING, Node.class, msgs);
+			msgs = basicSetSource(newSource, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__SOURCE, newSource, newSource));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Node getTarget() {
+		if (target != null && target.eIsProxy()) {
+			InternalEObject oldTarget = (InternalEObject)target;
+			target = (Node)eResolveProxy(oldTarget);
+			if (target != oldTarget) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.LINK__TARGET, oldTarget, target));
+			}
+		}
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Node basicGetTarget() {
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetTarget(Node newTarget, NotificationChain msgs) {
+		Node oldTarget = target;
+		target = newTarget;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__TARGET, oldTarget, newTarget);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setTarget(Node newTarget) {
+		if (newTarget != target) {
+			NotificationChain msgs = null;
+			if (target != null)
+				msgs = ((InternalEObject)target).eInverseRemove(this, FsmGenPackage.NODE__INCOMING, Node.class, msgs);
+			if (newTarget != null)
+				msgs = ((InternalEObject)newTarget).eInverseAdd(this, FsmGenPackage.NODE__INCOMING, Node.class, msgs);
+			msgs = basicSetTarget(newTarget, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__TARGET, newTarget, newTarget));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Link> getChainHeads() {
+		if (chainHeads == null) {
+			chainHeads = new EObjectResolvingEList<Link>(Link.class, this, FsmGenPackage.LINK__CHAIN_HEADS);
+		}
+		return chainHeads;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isIfitemTriggered() {
+		return ifitemTriggered;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setIfitemTriggered(boolean newIfitemTriggered) {
+		boolean oldIfitemTriggered = ifitemTriggered;
+		ifitemTriggered = newIfitemTriggered;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__IFITEM_TRIGGERED, oldIfitemTriggered, ifitemTriggered));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EObject getCommonData() {
+		if (commonData != null && commonData.eIsProxy()) {
+			InternalEObject oldCommonData = (InternalEObject)commonData;
+			commonData = eResolveProxy(oldCommonData);
+			if (commonData != oldCommonData) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.LINK__COMMON_DATA, oldCommonData, commonData));
+			}
+		}
+		return commonData;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EObject basicGetCommonData() {
+		return commonData;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setCommonData(EObject newCommonData) {
+		EObject oldCommonData = commonData;
+		commonData = newCommonData;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__COMMON_DATA, oldCommonData, commonData));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public TransitionBase getTransition() {
+		if (transition != null && transition.eIsProxy()) {
+			InternalEObject oldTransition = (InternalEObject)transition;
+			transition = (TransitionBase)eResolveProxy(oldTransition);
+			if (transition != oldTransition) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.LINK__TRANSITION, oldTransition, transition));
+			}
+		}
+		return transition;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public TransitionBase basicGetTransition() {
+		return transition;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setTransition(TransitionBase newTransition) {
+		TransitionBase oldTransition = transition;
+		transition = newTransition;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.LINK__TRANSITION, oldTransition, transition));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String toString() {
+		if (getTransition() instanceof InitialTransition) {
+			return "Link initial -> " + getTarget().toString() + " (InitialTransition)";
+		}
+		else if (getTransition() instanceof NonInitialTransition) {
+			return "Link " + getSource().toString() + " -> " + getTarget().toString() + " (NonInitialTransition)";
+		}
+		else if (getTransition() instanceof RefinedTransition) {
+			return "RefinedTransition";
+		}
+		return "?";
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetGraph((Graph)otherEnd, msgs);
+			case FsmGenPackage.LINK__SOURCE:
+				if (source != null)
+					msgs = ((InternalEObject)source).eInverseRemove(this, FsmGenPackage.NODE__OUTGOING, Node.class, msgs);
+				return basicSetSource((Node)otherEnd, msgs);
+			case FsmGenPackage.LINK__TARGET:
+				if (target != null)
+					msgs = ((InternalEObject)target).eInverseRemove(this, FsmGenPackage.NODE__INCOMING, Node.class, msgs);
+				return basicSetTarget((Node)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				return basicSetGraph(null, msgs);
+			case FsmGenPackage.LINK__SOURCE:
+				return basicSetSource(null, msgs);
+			case FsmGenPackage.LINK__TARGET:
+				return basicSetTarget(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
+		switch (eContainerFeatureID()) {
+			case FsmGenPackage.LINK__GRAPH:
+				return eInternalContainer().eInverseRemove(this, FsmGenPackage.GRAPH__LINKS, Graph.class, msgs);
+		}
+		return super.eBasicRemoveFromContainerFeature(msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				return getGraph();
+			case FsmGenPackage.LINK__SOURCE:
+				if (resolve) return getSource();
+				return basicGetSource();
+			case FsmGenPackage.LINK__TARGET:
+				if (resolve) return getTarget();
+				return basicGetTarget();
+			case FsmGenPackage.LINK__CHAIN_HEADS:
+				return getChainHeads();
+			case FsmGenPackage.LINK__IFITEM_TRIGGERED:
+				return isIfitemTriggered();
+			case FsmGenPackage.LINK__COMMON_DATA:
+				if (resolve) return getCommonData();
+				return basicGetCommonData();
+			case FsmGenPackage.LINK__TRANSITION:
+				if (resolve) return getTransition();
+				return basicGetTransition();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				setGraph((Graph)newValue);
+				return;
+			case FsmGenPackage.LINK__SOURCE:
+				setSource((Node)newValue);
+				return;
+			case FsmGenPackage.LINK__TARGET:
+				setTarget((Node)newValue);
+				return;
+			case FsmGenPackage.LINK__CHAIN_HEADS:
+				getChainHeads().clear();
+				getChainHeads().addAll((Collection<? extends Link>)newValue);
+				return;
+			case FsmGenPackage.LINK__IFITEM_TRIGGERED:
+				setIfitemTriggered((Boolean)newValue);
+				return;
+			case FsmGenPackage.LINK__COMMON_DATA:
+				setCommonData((EObject)newValue);
+				return;
+			case FsmGenPackage.LINK__TRANSITION:
+				setTransition((TransitionBase)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				setGraph((Graph)null);
+				return;
+			case FsmGenPackage.LINK__SOURCE:
+				setSource((Node)null);
+				return;
+			case FsmGenPackage.LINK__TARGET:
+				setTarget((Node)null);
+				return;
+			case FsmGenPackage.LINK__CHAIN_HEADS:
+				getChainHeads().clear();
+				return;
+			case FsmGenPackage.LINK__IFITEM_TRIGGERED:
+				setIfitemTriggered(IFITEM_TRIGGERED_EDEFAULT);
+				return;
+			case FsmGenPackage.LINK__COMMON_DATA:
+				setCommonData((EObject)null);
+				return;
+			case FsmGenPackage.LINK__TRANSITION:
+				setTransition((TransitionBase)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.LINK__GRAPH:
+				return getGraph() != null;
+			case FsmGenPackage.LINK__SOURCE:
+				return source != null;
+			case FsmGenPackage.LINK__TARGET:
+				return target != null;
+			case FsmGenPackage.LINK__CHAIN_HEADS:
+				return chainHeads != null && !chainHeads.isEmpty();
+			case FsmGenPackage.LINK__IFITEM_TRIGGERED:
+				return ifitemTriggered != IFITEM_TRIGGERED_EDEFAULT;
+			case FsmGenPackage.LINK__COMMON_DATA:
+				return commonData != null;
+			case FsmGenPackage.LINK__TRANSITION:
+				return transition != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException {
+		switch (operationID) {
+			case FsmGenPackage.LINK___TO_STRING:
+				return toString();
+		}
+		return super.eInvoke(operationID, arguments);
+	}
+
+} //LinkImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/NodeImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/NodeImpl.java
new file mode 100644
index 000000000..edd491e7c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/NodeImpl.java
@@ -0,0 +1,543 @@
+/**
+ */
+package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.RefinedState;
+import org.eclipse.etrice.core.fsm.fSM.SimpleState;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Node</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getGraph <em>Graph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getSubgraph <em>Subgraph</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getOutgoing <em>Outgoing</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getIncoming <em>Incoming</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getStateGraphNode <em>State Graph Node</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getCaughtTriggers <em>Caught Triggers</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.NodeImpl#getInheritanceLevel <em>Inheritance Level</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class NodeImpl extends GraphItemImpl implements Node {
+	/**
+	 * The cached value of the '{@link #getSubgraph() <em>Subgraph</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSubgraph()
+	 * @generated
+	 * @ordered
+	 */
+	protected Graph subgraph;
+
+	/**
+	 * The cached value of the '{@link #getOutgoing() <em>Outgoing</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getOutgoing()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Link> outgoing;
+
+	/**
+	 * The cached value of the '{@link #getIncoming() <em>Incoming</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getIncoming()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Link> incoming;
+
+	/**
+	 * The cached value of the '{@link #getStateGraphNode() <em>State Graph Node</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getStateGraphNode()
+	 * @generated
+	 * @ordered
+	 */
+	protected StateGraphNode stateGraphNode;
+
+	/**
+	 * The cached value of the '{@link #getCaughtTriggers() <em>Caught Triggers</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCaughtTriggers()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CommonTrigger> caughtTriggers;
+
+	/**
+	 * The default value of the '{@link #getInheritanceLevel() <em>Inheritance Level</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getInheritanceLevel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int INHERITANCE_LEVEL_EDEFAULT = 0;
+
+	/**
+	 * The cached value of the '{@link #getInheritanceLevel() <em>Inheritance Level</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getInheritanceLevel()
+	 * @generated
+	 * @ordered
+	 */
+	protected int inheritanceLevel = INHERITANCE_LEVEL_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected NodeImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return FsmGenPackage.Literals.NODE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Graph getGraph() {
+		if (eContainerFeatureID() != FsmGenPackage.NODE__GRAPH) return null;
+		return (Graph)eInternalContainer();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetGraph(Graph newGraph, NotificationChain msgs) {
+		msgs = eBasicSetContainer((InternalEObject)newGraph, FsmGenPackage.NODE__GRAPH, msgs);
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setGraph(Graph newGraph) {
+		if (newGraph != eInternalContainer() || (eContainerFeatureID() != FsmGenPackage.NODE__GRAPH && newGraph != null)) {
+			if (EcoreUtil.isAncestor(this, newGraph))
+				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
+			NotificationChain msgs = null;
+			if (eInternalContainer() != null)
+				msgs = eBasicRemoveFromContainer(msgs);
+			if (newGraph != null)
+				msgs = ((InternalEObject)newGraph).eInverseAdd(this, FsmGenPackage.GRAPH__NODES, Graph.class, msgs);
+			msgs = basicSetGraph(newGraph, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.NODE__GRAPH, newGraph, newGraph));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Graph getSubgraph() {
+		return subgraph;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetSubgraph(Graph newSubgraph, NotificationChain msgs) {
+		Graph oldSubgraph = subgraph;
+		subgraph = newSubgraph;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.NODE__SUBGRAPH, oldSubgraph, newSubgraph);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSubgraph(Graph newSubgraph) {
+		if (newSubgraph != subgraph) {
+			NotificationChain msgs = null;
+			if (subgraph != null)
+				msgs = ((InternalEObject)subgraph).eInverseRemove(this, FsmGenPackage.GRAPH__NODE, Graph.class, msgs);
+			if (newSubgraph != null)
+				msgs = ((InternalEObject)newSubgraph).eInverseAdd(this, FsmGenPackage.GRAPH__NODE, Graph.class, msgs);
+			msgs = basicSetSubgraph(newSubgraph, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.NODE__SUBGRAPH, newSubgraph, newSubgraph));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Link> getOutgoing() {
+		if (outgoing == null) {
+			outgoing = new EObjectWithInverseResolvingEList<Link>(Link.class, this, FsmGenPackage.NODE__OUTGOING, FsmGenPackage.LINK__SOURCE);
+		}
+		return outgoing;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Link> getIncoming() {
+		if (incoming == null) {
+			incoming = new EObjectWithInverseResolvingEList<Link>(Link.class, this, FsmGenPackage.NODE__INCOMING, FsmGenPackage.LINK__TARGET);
+		}
+		return incoming;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public StateGraphNode getStateGraphNode() {
+		if (stateGraphNode != null && stateGraphNode.eIsProxy()) {
+			InternalEObject oldStateGraphNode = (InternalEObject)stateGraphNode;
+			stateGraphNode = (StateGraphNode)eResolveProxy(oldStateGraphNode);
+			if (stateGraphNode != oldStateGraphNode) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.NODE__STATE_GRAPH_NODE, oldStateGraphNode, stateGraphNode));
+			}
+		}
+		return stateGraphNode;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public StateGraphNode basicGetStateGraphNode() {
+		return stateGraphNode;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setStateGraphNode(StateGraphNode newStateGraphNode) {
+		StateGraphNode oldStateGraphNode = stateGraphNode;
+		stateGraphNode = newStateGraphNode;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.NODE__STATE_GRAPH_NODE, oldStateGraphNode, stateGraphNode));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<CommonTrigger> getCaughtTriggers() {
+		if (caughtTriggers == null) {
+			caughtTriggers = new EObjectContainmentEList<CommonTrigger>(CommonTrigger.class, this, FsmGenPackage.NODE__CAUGHT_TRIGGERS);
+		}
+		return caughtTriggers;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public int getInheritanceLevel() {
+		return inheritanceLevel;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setInheritanceLevel(int newInheritanceLevel) {
+		int oldInheritanceLevel = inheritanceLevel;
+		inheritanceLevel = newInheritanceLevel;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.NODE__INHERITANCE_LEVEL, oldInheritanceLevel, inheritanceLevel));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String toString() {
+		String type = "?";
+		if (getStateGraphNode() instanceof RefinedState) {
+			type = "RefinedState";
+		}
+		else if (getStateGraphNode() instanceof SimpleState) {
+			type = "SimpleState";
+		}
+		else if (getStateGraphNode() instanceof TrPoint) {
+			type = "TrPoint";
+		}
+		else if (getStateGraphNode() instanceof ChoicePoint) {
+			type = "ChoicePoint";
+		}
+		return "Node " + getStateGraphNode().getName() + " (" + type + ")";
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetGraph((Graph)otherEnd, msgs);
+			case FsmGenPackage.NODE__SUBGRAPH:
+				if (subgraph != null)
+					msgs = ((InternalEObject)subgraph).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.NODE__SUBGRAPH, null, msgs);
+				return basicSetSubgraph((Graph)otherEnd, msgs);
+			case FsmGenPackage.NODE__OUTGOING:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOutgoing()).basicAdd(otherEnd, msgs);
+			case FsmGenPackage.NODE__INCOMING:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getIncoming()).basicAdd(otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				return basicSetGraph(null, msgs);
+			case FsmGenPackage.NODE__SUBGRAPH:
+				return basicSetSubgraph(null, msgs);
+			case FsmGenPackage.NODE__OUTGOING:
+				return ((InternalEList<?>)getOutgoing()).basicRemove(otherEnd, msgs);
+			case FsmGenPackage.NODE__INCOMING:
+				return ((InternalEList<?>)getIncoming()).basicRemove(otherEnd, msgs);
+			case FsmGenPackage.NODE__CAUGHT_TRIGGERS:
+				return ((InternalEList<?>)getCaughtTriggers()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
+		switch (eContainerFeatureID()) {
+			case FsmGenPackage.NODE__GRAPH:
+				return eInternalContainer().eInverseRemove(this, FsmGenPackage.GRAPH__NODES, Graph.class, msgs);
+		}
+		return super.eBasicRemoveFromContainerFeature(msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				return getGraph();
+			case FsmGenPackage.NODE__SUBGRAPH:
+				return getSubgraph();
+			case FsmGenPackage.NODE__OUTGOING:
+				return getOutgoing();
+			case FsmGenPackage.NODE__INCOMING:
+				return getIncoming();
+			case FsmGenPackage.NODE__STATE_GRAPH_NODE:
+				if (resolve) return getStateGraphNode();
+				return basicGetStateGraphNode();
+			case FsmGenPackage.NODE__CAUGHT_TRIGGERS:
+				return getCaughtTriggers();
+			case FsmGenPackage.NODE__INHERITANCE_LEVEL:
+				return getInheritanceLevel();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				setGraph((Graph)newValue);
+				return;
+			case FsmGenPackage.NODE__SUBGRAPH:
+				setSubgraph((Graph)newValue);
+				return;
+			case FsmGenPackage.NODE__OUTGOING:
+				getOutgoing().clear();
+				getOutgoing().addAll((Collection<? extends Link>)newValue);
+				return;
+			case FsmGenPackage.NODE__INCOMING:
+				getIncoming().clear();
+				getIncoming().addAll((Collection<? extends Link>)newValue);
+				return;
+			case FsmGenPackage.NODE__STATE_GRAPH_NODE:
+				setStateGraphNode((StateGraphNode)newValue);
+				return;
+			case FsmGenPackage.NODE__CAUGHT_TRIGGERS:
+				getCaughtTriggers().clear();
+				getCaughtTriggers().addAll((Collection<? extends CommonTrigger>)newValue);
+				return;
+			case FsmGenPackage.NODE__INHERITANCE_LEVEL:
+				setInheritanceLevel((Integer)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				setGraph((Graph)null);
+				return;
+			case FsmGenPackage.NODE__SUBGRAPH:
+				setSubgraph((Graph)null);
+				return;
+			case FsmGenPackage.NODE__OUTGOING:
+				getOutgoing().clear();
+				return;
+			case FsmGenPackage.NODE__INCOMING:
+				getIncoming().clear();
+				return;
+			case FsmGenPackage.NODE__STATE_GRAPH_NODE:
+				setStateGraphNode((StateGraphNode)null);
+				return;
+			case FsmGenPackage.NODE__CAUGHT_TRIGGERS:
+				getCaughtTriggers().clear();
+				return;
+			case FsmGenPackage.NODE__INHERITANCE_LEVEL:
+				setInheritanceLevel(INHERITANCE_LEVEL_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case FsmGenPackage.NODE__GRAPH:
+				return getGraph() != null;
+			case FsmGenPackage.NODE__SUBGRAPH:
+				return subgraph != null;
+			case FsmGenPackage.NODE__OUTGOING:
+				return outgoing != null && !outgoing.isEmpty();
+			case FsmGenPackage.NODE__INCOMING:
+				return incoming != null && !incoming.isEmpty();
+			case FsmGenPackage.NODE__STATE_GRAPH_NODE:
+				return stateGraphNode != null;
+			case FsmGenPackage.NODE__CAUGHT_TRIGGERS:
+				return caughtTriggers != null && !caughtTriggers.isEmpty();
+			case FsmGenPackage.NODE__INHERITANCE_LEVEL:
+				return inheritanceLevel != INHERITANCE_LEVEL_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException {
+		switch (operationID) {
+			case FsmGenPackage.NODE___TO_STRING:
+				return toString();
+		}
+		return super.eInvoke(operationID, arguments);
+	}
+
+} //NodeImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenAdapterFactory.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenAdapterFactory.java
index e05a7595c..b798bea30 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenAdapterFactory.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenAdapterFactory.java
@@ -1,13 +1,4 @@
 /**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
  */
 package org.eclipse.etrice.core.genmodel.fsm.fsmgen.util;
 
@@ -18,11 +9,6 @@ import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 
 import org.eclipse.emf.ecore.EObject;
 
-import org.eclipse.etrice.core.fsm.fSM.SimpleState;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-
 import org.eclipse.etrice.core.genmodel.fsm.fsmgen.*;
 
 /**
@@ -82,44 +68,32 @@ public class FsmGenAdapterFactory extends AdapterFactoryImpl {
 	protected FsmGenSwitch<Adapter> modelSwitch =
 		new FsmGenSwitch<Adapter>() {
 			@Override
-			public Adapter caseActiveTrigger(ActiveTrigger object) {
-				return createActiveTriggerAdapter();
-			}
-			@Override
-			public Adapter caseExpandedModelComponent(ExpandedModelComponent object) {
-				return createExpandedModelComponentAdapter();
-			}
-			@Override
-			public Adapter caseExpandedRefinedState(ExpandedRefinedState object) {
-				return createExpandedRefinedStateAdapter();
+			public Adapter caseGraphContainer(GraphContainer object) {
+				return createGraphContainerAdapter();
 			}
 			@Override
-			public Adapter caseIDiagnostician(IDiagnostician object) {
-				return createIDiagnosticianAdapter();
+			public Adapter caseGraph(Graph object) {
+				return createGraphAdapter();
 			}
 			@Override
-			public Adapter caseITransitionChainVisitor(ITransitionChainVisitor object) {
-				return createITransitionChainVisitorAdapter();
+			public Adapter caseGraphItem(GraphItem object) {
+				return createGraphItemAdapter();
 			}
 			@Override
-			public Adapter caseTransitionChain(TransitionChain object) {
-				return createTransitionChainAdapter();
+			public Adapter caseNode(Node object) {
+				return createNodeAdapter();
 			}
 			@Override
-			public Adapter caseStateGraphItem(StateGraphItem object) {
-				return createStateGraphItemAdapter();
+			public Adapter caseLink(Link object) {
+				return createLinkAdapter();
 			}
 			@Override
-			public Adapter caseStateGraphNode(StateGraphNode object) {
-				return createStateGraphNodeAdapter();
+			public Adapter caseCommonTrigger(CommonTrigger object) {
+				return createCommonTriggerAdapter();
 			}
 			@Override
-			public Adapter caseState(State object) {
-				return createStateAdapter();
-			}
-			@Override
-			public Adapter caseSimpleState(SimpleState object) {
-				return createSimpleStateAdapter();
+			public Adapter caseFSMGenElement(FSMGenElement object) {
+				return createFSMGenElementAdapter();
 			}
 			@Override
 			public Adapter defaultCase(EObject object) {
@@ -142,142 +116,100 @@ public class FsmGenAdapterFactory extends AdapterFactoryImpl {
 
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger <em>Active Trigger</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger
-	 * @generated
-	 */
-	public Adapter createActiveTriggerAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent <em>Expanded Model Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-	 * @generated
-	 */
-	public Adapter createExpandedModelComponentAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState <em>Expanded Refined State</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState
-	 * @generated
-	 */
-	public Adapter createExpandedRefinedStateAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link IDiagnostician <em>IDiagnostician</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer <em>Graph Container</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see IDiagnostician
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
 	 * @generated
 	 */
-	public Adapter createIDiagnosticianAdapter() {
+	public Adapter createGraphContainerAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link ITransitionChainVisitor <em>ITransition Chain Visitor</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph <em>Graph</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see ITransitionChainVisitor
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
 	 * @generated
 	 */
-	public Adapter createITransitionChainVisitorAdapter() {
+	public Adapter createGraphAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain <em>Transition Chain</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem <em>Graph Item</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphItem
 	 * @generated
 	 */
-	public Adapter createTransitionChainAdapter() {
+	public Adapter createGraphItemAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.fsm.fSM.StateGraphItem <em>State Graph Item</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node <em>Node</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.fsm.fSM.StateGraphItem
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
 	 * @generated
 	 */
-	public Adapter createStateGraphItemAdapter() {
+	public Adapter createNodeAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.fsm.fSM.StateGraphNode <em>State Graph Node</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link <em>Link</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.fsm.fSM.StateGraphNode
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
 	 * @generated
 	 */
-	public Adapter createStateGraphNodeAdapter() {
+	public Adapter createLinkAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.fsm.fSM.State <em>State</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger <em>Common Trigger</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.fsm.fSM.State
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger
 	 * @generated
 	 */
-	public Adapter createStateAdapter() {
+	public Adapter createCommonTriggerAdapter() {
 		return null;
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.fsm.fSM.SimpleState <em>Simple State</em>}'.
+	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement <em>FSM Gen Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
 	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.fsm.fSM.SimpleState
+	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement
 	 * @generated
 	 */
-	public Adapter createSimpleStateAdapter() {
+	public Adapter createFSMGenElementAdapter() {
 		return null;
 	}
 
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenSwitch.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenSwitch.java
index 7c319b444..64d86c43d 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenSwitch.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src-gen/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenSwitch.java
@@ -1,13 +1,4 @@
 /**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
  */
 package org.eclipse.etrice.core.genmodel.fsm.fsmgen.util;
 
@@ -16,11 +7,6 @@ import org.eclipse.emf.ecore.EPackage;
 
 import org.eclipse.emf.ecore.util.Switch;
 
-import org.eclipse.etrice.core.fsm.fSM.SimpleState;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-
 import org.eclipse.etrice.core.genmodel.fsm.fsmgen.*;
 
 /**
@@ -61,7 +47,7 @@ public class FsmGenSwitch<T> extends Switch<T> {
 	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @parameter ePackage the package in question.
+	 * @param ePackage the package in question.
 	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
@@ -80,43 +66,53 @@ public class FsmGenSwitch<T> extends Switch<T> {
 	@Override
 	protected T doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
-			case FsmGenPackage.ACTIVE_TRIGGER: {
-				ActiveTrigger activeTrigger = (ActiveTrigger)theEObject;
-				T result = caseActiveTrigger(activeTrigger);
+			case FsmGenPackage.GRAPH_CONTAINER: {
+				GraphContainer graphContainer = (GraphContainer)theEObject;
+				T result = caseGraphContainer(graphContainer);
+				if (result == null) result = caseFSMGenElement(graphContainer);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT: {
-				ExpandedModelComponent expandedModelComponent = (ExpandedModelComponent)theEObject;
-				T result = caseExpandedModelComponent(expandedModelComponent);
+			case FsmGenPackage.GRAPH: {
+				Graph graph = (Graph)theEObject;
+				T result = caseGraph(graph);
+				if (result == null) result = caseFSMGenElement(graph);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case FsmGenPackage.EXPANDED_REFINED_STATE: {
-				ExpandedRefinedState expandedRefinedState = (ExpandedRefinedState)theEObject;
-				T result = caseExpandedRefinedState(expandedRefinedState);
-				if (result == null) result = caseSimpleState(expandedRefinedState);
-				if (result == null) result = caseState(expandedRefinedState);
-				if (result == null) result = caseStateGraphNode(expandedRefinedState);
-				if (result == null) result = caseStateGraphItem(expandedRefinedState);
+			case FsmGenPackage.GRAPH_ITEM: {
+				GraphItem graphItem = (GraphItem)theEObject;
+				T result = caseGraphItem(graphItem);
+				if (result == null) result = caseFSMGenElement(graphItem);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case FsmGenPackage.IDIAGNOSTICIAN: {
-				IDiagnostician iDiagnostician = (IDiagnostician)theEObject;
-				T result = caseIDiagnostician(iDiagnostician);
+			case FsmGenPackage.NODE: {
+				Node node = (Node)theEObject;
+				T result = caseNode(node);
+				if (result == null) result = caseGraphItem(node);
+				if (result == null) result = caseFSMGenElement(node);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case FsmGenPackage.ITRANSITION_CHAIN_VISITOR: {
-				ITransitionChainVisitor iTransitionChainVisitor = (ITransitionChainVisitor)theEObject;
-				T result = caseITransitionChainVisitor(iTransitionChainVisitor);
+			case FsmGenPackage.LINK: {
+				Link link = (Link)theEObject;
+				T result = caseLink(link);
+				if (result == null) result = caseGraphItem(link);
+				if (result == null) result = caseFSMGenElement(link);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case FsmGenPackage.TRANSITION_CHAIN: {
-				TransitionChain transitionChain = (TransitionChain)theEObject;
-				T result = caseTransitionChain(transitionChain);
+			case FsmGenPackage.COMMON_TRIGGER: {
+				CommonTrigger commonTrigger = (CommonTrigger)theEObject;
+				T result = caseCommonTrigger(commonTrigger);
+				if (result == null) result = caseFSMGenElement(commonTrigger);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case FsmGenPackage.FSM_GEN_ELEMENT: {
+				FSMGenElement fsmGenElement = (FSMGenElement)theEObject;
+				T result = caseFSMGenElement(fsmGenElement);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
@@ -125,152 +121,107 @@ public class FsmGenSwitch<T> extends Switch<T> {
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Active Trigger</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Active Trigger</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseActiveTrigger(ActiveTrigger object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Expanded Model Component</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Expanded Model Component</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseExpandedModelComponent(ExpandedModelComponent object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Expanded Refined State</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Expanded Refined State</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseExpandedRefinedState(ExpandedRefinedState object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>IDiagnostician</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Graph Container</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>IDiagnostician</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Graph Container</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseIDiagnostician(IDiagnostician object) {
+	public T caseGraphContainer(GraphContainer object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>ITransition Chain Visitor</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Graph</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>ITransition Chain Visitor</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Graph</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseITransitionChainVisitor(ITransitionChainVisitor object) {
+	public T caseGraph(Graph object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Transition Chain</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Graph Item</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Transition Chain</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Graph Item</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseTransitionChain(TransitionChain object) {
+	public T caseGraphItem(GraphItem object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>State Graph Item</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Node</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>State Graph Item</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Node</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseStateGraphItem(StateGraphItem object) {
+	public T caseNode(Node object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>State Graph Node</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Link</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>State Graph Node</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Link</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseStateGraphNode(StateGraphNode object) {
+	public T caseLink(Link object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>State</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>Common Trigger</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>State</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>Common Trigger</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseState(State object) {
+	public T caseCommonTrigger(CommonTrigger object) {
 		return null;
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Simple State</em>'.
+	 * Returns the result of interpreting the object as an instance of '<em>FSM Gen Element</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
 	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Simple State</em>'.
+	 * @return the result of interpreting the object as an instance of '<em>FSM Gen Element</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
-	public T caseSimpleState(SimpleState object) {
+	public T caseFSMGenElement(FSMGenElement object) {
 		return null;
 	}
 
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.xtend b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.xtend
new file mode 100644
index 000000000..622e427cb
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.xtend
@@ -0,0 +1,166 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm
+
+import com.google.inject.Inject
+import com.google.inject.Injector
+import org.eclipse.etrice.core.fsm.fSM.ChoicepointTerminal
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition
+import org.eclipse.etrice.core.fsm.fSM.RefinedState
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition
+import org.eclipse.etrice.core.fsm.fSM.SimpleState
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.StateGraph
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode
+import org.eclipse.etrice.core.fsm.fSM.StateTerminal
+import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal
+import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal
+import org.eclipse.etrice.core.fsm.fSM.Transition
+import org.eclipse.etrice.core.fsm.util.FSMHelpers
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+
+class BasicFsmGenBuilder {
+	
+	@Inject
+	protected extension FSMHelpers fsmHelpers
+	
+	protected val factory = FsmGenFactory.eINSTANCE
+	private var int inheritanceLevel = 0
+	
+	new(Injector injector) {
+		injector.injectMembers(this)
+	}
+
+	// protected constructor leaves injection to super class
+	protected new() {
+	}
+		
+	def GraphContainer createTransformedModel(ModelComponent mc) {
+		mc.createContainer
+	}
+	
+	private def GraphContainer create factory.createGraphContainer createContainer(ModelComponent mc) {
+		it.component = mc
+		it.graph = createStateMachine(mc)
+	}
+	
+	private def Graph createStateMachine(ModelComponent mc) {
+		// neither we nor all of our base classes need to have a state machine.
+		// So we ask for the super state machine rather than for the base class'
+		// state machine
+		val superFSM = mc.superStateMachine
+		
+		if (superFSM!==null) {
+			// if we have a super state machine we first recurse down
+			val baseGraph = createStateMachine(superFSM.modelComponent)
+			
+			// when we ascend from the recursion we increment the inheritanceLevel
+			inheritanceLevel++
+			
+			// and then merge with our (actual) state machine
+			mergeGraph(baseGraph, mc.actualStateMachine)
+		}
+		else if (mc.actualStateMachine!==null) {
+			// first state machine in the hierarchy: create it
+			mc.actualStateMachine?.createGraph
+		}
+	}
+	
+	private def Graph mergeGraph(Graph graph, StateGraph sg) {
+		// mark existing items as inherited
+		graph.nodes.forEach[inherited = true]
+		graph.links.forEach[inherited = true]
+		
+		// add items to already existing graph
+		graph.createContents(sg)
+		
+		// point to the current state graph
+		graph.stateGraph = sg
+		
+		return graph
+	}
+	
+	private def Graph create factory.createGraph createGraph(StateGraph sg) {
+		it.stateGraph = sg
+		createContents(sg)
+	}
+	
+	private def createContents(Graph graph, StateGraph sg) {
+		graph.nodes.addAll(sg.chPoints.map[createNode])
+		graph.nodes.addAll(sg.trPoints.map[createNode])
+		graph.nodes.addAll(sg.states.filter(typeof(SimpleState)).map[createNode])
+		graph.links.addAll(sg.transitions.map[createLink])
+		
+		// refined states and refined transitions
+		sg.states.filter(typeof(RefinedState)).forEach[handleRefinedState]
+		sg.refinedTransitions.forEach[handleRefinedTransition]
+	}
+	
+	private def handleRefinedState(RefinedState s) {
+		// we pick the node that initially was created from a SimpleState
+		val refinedNode = s.finalTarget.createNode
+		
+		// handle the sub graphs
+		if (s.subgraph!==null) {
+			if (refinedNode.subgraph!==null) {
+				refinedNode.subgraph.mergeGraph(s.subgraph)
+			}
+			else {
+				refinedNode.subgraph = s.subgraph.createGraph
+			}
+		}
+		// else nothing to do, whether the targetGraph exists or not
+		
+		// change the target Node's stateGraphNode to our RefinedState
+		val target = refinedNode
+		target.stateGraphNode = s
+	}
+	
+	private def handleRefinedTransition(RefinedTransition t) {
+		// change the target link's transition to the refined transition
+		t.target.createLink.transition = t
+	}
+	
+	private def Link create factory.createLink createLink(Transition tr) {
+		it.transition = tr
+		it.source = if (tr instanceof NonInitialTransition) tr.from.createNode
+		it.target = tr.to.createNode
+	}
+	
+	private def dispatch create factory.createNode createNode(StateGraphNode s) {
+		it.stateGraphNode = s
+		it.inheritanceLevel = inheritanceLevel
+		it.subgraph = if(s instanceof State) s.subgraph?.createGraph
+	}
+	
+	private def dispatch Node createNode(ChoicepointTerminal tt) {
+		tt.cp.createNode
+	}
+	
+	private def dispatch Node createNode(TrPointTerminal tt) {
+		tt.trPoint.createNode
+	}
+	
+	private def dispatch Node createNode(StateTerminal tt) {
+		tt.state.createNode
+	}
+	
+	private def dispatch Node createNode(SubStateTrPointTerminal tt) {
+		tt.trPoint.createNode
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.xtend b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.xtend
new file mode 100644
index 000000000..643f138ff
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.xtend
@@ -0,0 +1,243 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		hrr@protos.de (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm
+
+import com.google.inject.Inject
+import com.google.inject.Injector
+import java.util.HashMap
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EStructuralFeature
+import org.eclipse.etrice.core.fsm.fSM.FSMPackage
+import org.eclipse.etrice.core.fsm.fSM.MessageFromIf
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.TransitionPoint
+import org.eclipse.etrice.core.fsm.fSM.Trigger
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+
+class ExtendedFsmGenBuilder extends BasicFsmGenBuilder {
+
+	@Inject
+	protected extension ICommonDataCalculator
+	@Inject
+	protected extension TriggerExtensions
+	
+	protected IDiagnostician validator
+	
+	val factory = FsmGenFactory.eINSTANCE
+	
+	new(Injector injector) {
+		this(injector, null)
+	}
+	
+	new(Injector injector, IDiagnostician validator) {
+		super()
+		injector.injectMembers(this)
+		this.validator = if(validator === null) new NullDiagnostician else validator
+	}
+	
+	/**
+	 * computes the available triggers for all leaf states
+	 */
+	def withTriggersInStates(GraphContainer gc) {
+		if (!gc.initializedTriggersInStates) {
+			if (gc.graph!==null) {
+				gc.graph.allStateNodes.filter[subgraph===null].forEach[computeTriggers]
+			}
+			gc.initializedTriggersInStates = true
+		}
+		
+		return gc
+	}
+	
+	/**
+	 * determines all transition chain heads of all transitions
+	 */
+	def withChainHeads(GraphContainer gc) {
+		if (!gc.initializedChainHeads) {
+			if (gc.graph!==null) {
+				gc.graph.allChainHeads.forEach[it.followChain(it)]
+			}
+			gc.initializedChainHeads = true
+		}
+		
+		return gc
+	}
+	
+	/**
+	 * calculates and stores the common data. Prerequisite is the computation of the
+	 * chain heads, which is performed if not done already.
+	 */
+	def withCommonData(GraphContainer gc) {
+		if (!gc.initializedChainHeads) {
+			gc.withChainHeads
+		}
+		if (!gc.initializedCommonData) {
+			if (gc.graph!==null) {
+				gc.graph.allLinks.forEach[commonData = calculateCommonData]
+			}
+			gc.initializedCommonData = true
+		}
+		
+		return gc
+	}
+	
+	private def void followChain(Link l, Link head) {
+		// if we started at an initial or guarded transition no interface item can be provided
+		if (!(head.transition instanceof TriggeredTransition)) {
+			l.ifitemTriggered = false
+		}
+		
+		// add our chain head
+		l.chainHeads.add(head)
+		
+		// have a look at the target node: the chain terminates in states and in transition points
+		val target = l.target.stateGraphNode
+		if (target instanceof State || target instanceof TransitionPoint) {
+			return
+		}
+		else {
+			// follow all outgoing links recursively
+			for (next : l.target.outgoing) {
+				next.followChain(head)
+			}
+		}
+	}
+	
+	private def void computeTriggers(Node s) {
+		// we use a linked HashMap to preserve the order (insertion) to facilitate testability
+		val caughtTriggers = <String, CommonTrigger>newLinkedHashMap
+		
+		s.computeTriggersRecursive(caughtTriggers)
+		
+		// make it safe against a duplicate call
+		s.caughtTriggers.clear
+		
+		// transfer the result
+		s.caughtTriggers.addAll(caughtTriggers.values)
+	}
+	
+	private def void computeTriggersRecursive(Node s, HashMap<String, CommonTrigger> caughtTriggers) {
+		// first visit this state: consider all outgoing triggered transitions
+		s.outgoingTriggeredTransitionLinks.toList.computeTriggers(caughtTriggers)
+		
+		// then handle transition points: consider all outgoing triggered transitions of ALL
+		// transition points of the parent graph of this state
+		val trPointTransitions = s.graph.transitionPointNodes.map[outgoingTriggeredTransitionLinks].flatten.toList
+		trPointTransitions.computeTriggers(caughtTriggers)
+		
+		// recursively ascend to surrounding context
+		if (!s.graph.isTopLevel) {
+			s.parentState.computeTriggersRecursive(caughtTriggers)
+		}
+	}
+	
+	private def void computeTriggers(List<Link> sameLevelLinks, HashMap<String, CommonTrigger> caughtTriggers) {
+		// we need a mapping from transitions to links below
+		val trans2link = newHashMap
+		sameLevelLinks.forEach[trans2link.put(transition, it)]
+		
+		for (l : sameLevelLinks) {
+			for (tr : (l.transition as TriggeredTransition).triggers) {
+				val triggerHasGuard = tr.hasGuard
+				for (mif : tr.msgFromIfPairs) {
+					val tag = mif.triggerTag
+					var ct = caughtTriggers.get(tag)
+					
+					/*
+					 * accept new trigger if
+					 * 
+					 *  - no inner or inner with guard
+					 *  - accept several but only one without guard (count),
+					 *    insert those with guard first in the list of the _same_ level(!)
+					 */
+					if (ct===null) {
+						// no inner transition with this trigger exists yet,
+						// so this is a new trigger (and our unique point of CommonTrigger creation)
+						ct = l.createCommonTrigger(mif, tag)
+						ct.hasGuard = triggerHasGuard
+						caughtTriggers.put(tag, ct)
+					}
+					else {
+						// check guards of previous transitions: compare all triggers and
+						// find matching ones that aren't guarded
+						val unguarded = ct.links.map[(transition as TriggeredTransition).triggers].flatten.
+								filter[hasMatchingTrigger(tag) && !hasGuard].head?.eContainer as TriggeredTransition
+						
+						if (unguarded!==null) {
+							// we found an unguarded trigger in one of the previous transitions
+							
+							val unguardedLink = trans2link.get(unguarded)
+							if (sameLevelLinks.contains(unguardedLink)) {
+								// we have an unguarded transition
+								if (triggerHasGuard) {
+									// this case is valid. Now we add the transition RIGHT BEFORE the
+									// unguarded one we found on the same level
+									val idx = ct.links.indexOf(unguardedLink)
+									ct.hasGuard = triggerHasGuard
+									ct.links.add(idx, l)
+								}
+								else {
+									validationError("Transitions with same trigger on same level have to be guarded!", l.transition, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers())
+								}
+							}
+							//else {
+								// this trigger is hidden by a previous unguarded transition on a higher level.
+								// No action needed
+							//}
+						}
+						else {
+							// append this transition
+							ct.links.add(l)
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	private def boolean hasMatchingTrigger(Trigger trig, String tag) {
+		for (mifp2 : trig.msgFromIfPairs) {
+			val tr2 = mifp2.triggerTag
+			if (tr2.equals(tag)) {
+				return true
+			}
+		}
+		return false
+	}
+	
+	def private CommonTrigger createCommonTrigger(Link l, MessageFromIf mif, String tag) {
+		val it = factory.createCommonTrigger
+		it.trigger = tag
+		it.ifitem = mif.from
+		it.msg = mif.message
+		it.links.add(l)
+		
+		return it
+	}
+
+	protected def void validationError(String msg, EObject obj, EStructuralFeature feature) {
+		validationError(msg, obj, feature, IDiagnostician.INSIGNIFICANT_INDEX)
+	}
+	
+	protected def void validationError(String msg, EObject obj, EStructuralFeature feature, int idx) {
+		validator.error(msg, obj, feature, idx)
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.xtend b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.xtend
new file mode 100644
index 000000000..66f5adfff
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.xtend
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm
+
+import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+import org.eclipse.etrice.core.fsm.fSM.TrPoint
+import org.eclipse.etrice.core.fsm.fSM.State
+
+class FsmGenChecker {
+	
+	static def check(GraphContainer gc, ILogger logger) {
+		// graphs
+		gc.eAllContents.filter(typeof(Graph)).forEach[checkGraph(it, logger)]
+		
+		// nodes
+		gc.eAllContents.filter(typeof(Node)).forEach[checkNode(it, logger)]
+		
+		// links
+		gc.eAllContents.filter(typeof(Link)).forEach[checkLink(it, logger)]
+	}
+	
+	private static def void checkLink(Link it, ILogger logger) {
+		if (transition===null) {
+			logger.logError("graph doesn't point to ROOM transition")
+		}
+		else if (transition.eIsProxy) {
+			logger.logError("unresolved ROOM transition")
+		}
+		else if (transition.eContainer===null) {
+			logger.logError("dangling ROOM transition")
+		}
+		else if (target===null) {
+			logger.logError("link without target")
+		}
+		else if (source===null && transition instanceof NonInitialTransition) {
+			logger.logError("non-initial link without source")
+		}
+
+		if (source!==null) {
+			checkLinkEnd(it, it.source, logger)
+		}
+		checkLinkEnd(it, it.target, logger)
+	}
+	
+	private static def checkLinkEnd(Link link, Node node, ILogger logger) {
+		if (node.eContainer == link.eContainer) {
+			return;
+		}
+		else {
+			if (!(node.stateGraphNode instanceof TrPoint)) {
+				logger.logError("subgraph item is not transition point")
+			}
+			else if (!(node.eContainer.eContainer instanceof Node)) {
+				logger.logError("subgraph item is in unexpected container")
+			}
+			else if (!((node.eContainer.eContainer as Node).stateGraphNode instanceof State)) {
+				logger.logError("subgraph item is in unexpected container")
+			}
+			else if (node.eContainer.eContainer.eContainer != link.eContainer) {
+				logger.logError("subgraph item is in unexpected container")
+			}
+		}
+	}
+	
+	private static def void checkNode(Node it, ILogger logger) {
+		if (stateGraphNode===null) {
+			logger.logError("graph doesn't point to ROOM state graph node")
+		}
+		else if (stateGraphNode.eIsProxy) {
+			logger.logError("unresolved ROOM graph node")
+		}
+		else if (stateGraphNode.eContainer===null) {
+			logger.logError("dangling ROOM graph node")
+		}
+		else if (stateGraphNode.getName()===null) {
+			logger.logError("ROOM graph node without name")
+		}
+		else if (graph===null) {
+			logger.logError("node isn't contained in a graph")
+		}
+		
+		// incoming transitions
+		for (l : incoming) {
+			if (l.target.stateGraphNode != it.stateGraphNode) {
+				logger.logError("ROOM target node of an incoming transition must be myself")
+			}
+		}
+		
+		// outgoing transitions
+		for (l : outgoing) {
+			if (l.source.stateGraphNode != it.stateGraphNode) {
+				logger.logError("ROOM source node of an outgoing transition must be myself")
+			}
+		}
+	}
+	
+	private static def void checkGraph(Graph it, ILogger logger) {
+		if (stateGraph===null) {
+			logger.logError("graph doesn't point to ROOM state graph")
+		}
+		else if (stateGraph.eIsProxy) {
+			logger.logError("unresolved ROOM graph")
+		}
+		else if (stateGraph.eContainer===null) {
+			logger.logError("dangling ROOM graph")
+		}
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.xtend b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.xtend
new file mode 100644
index 000000000..7b5193dcc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.xtend
@@ -0,0 +1,280 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm
+
+import java.util.List
+import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.core.fsm.fSM.EntryPoint
+import org.eclipse.etrice.core.fsm.fSM.ExitPoint
+import org.eclipse.etrice.core.fsm.fSM.GuardedTransition
+import org.eclipse.etrice.core.fsm.fSM.InitialTransition
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.TrPoint
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase
+import org.eclipse.etrice.core.fsm.fSM.TransitionPoint
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+
+class FsmGenExtensions {
+	
+	public static def dispatch getName(Node nd) {
+		nd.stateGraphNode.name
+	}
+	
+	public static def dispatch getName(Link l) {
+		l.transition.name
+	}
+	
+	public static def getStateNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof State]
+	}
+	
+	public static def getAllNodes(Graph g) {
+		g.eAllContents.filter(typeof(Node))
+	}
+	
+	public static def getAllStateNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof State]
+	}
+	
+	public static def getChoicePointNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof ChoicePoint]
+	}
+	
+	public static def getAllChoicePointNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof ChoicePoint]
+	}
+	
+	public static def getTrPointNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof TrPoint]
+	}
+	
+	public static def getAllTrPointNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof TrPoint]
+	}
+	
+	public static def getTransitionPointNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof TransitionPoint]
+	}
+	
+	public static def getAllTransitionPointNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof TransitionPoint]
+	}
+	
+	public static def getEntryPointNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof EntryPoint]
+	}
+	
+	public static def getAllEntryPointNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof EntryPoint]
+	}
+	
+	public static def getExitPointNodes(Graph g) {
+		g.nodes.filter[stateGraphNode instanceof ExitPoint]
+	}
+	
+	public static def getAllExitPointNodes(Graph g) {
+		g.allNodes.filter[stateGraphNode instanceof ExitPoint]
+	}
+	
+	public static def getStates(Graph g) {
+		g.stateNodes.map[stateGraphNode].filter(typeof(State))
+	}
+	
+	public static def getAllStates(Graph g) {
+		g.allStateNodes.map[stateGraphNode].filter(typeof(State))
+	}
+	
+	public static def getChoicePoints(Graph g) {
+		g.choicePointNodes.map[stateGraphNode].filter(typeof(ChoicePoint))
+	}
+	
+	public static def getTrPoints(Graph g) {
+		g.trPointNodes.map[stateGraphNode].filter(typeof(TrPoint))
+	}
+	
+	public static def getInitialTransition(Graph g) {
+		g.links.map[transition].filter(typeof(InitialTransition)).head
+	}
+	
+	public static def getAllLinks(Graph g) {
+		g.eAllContents.filter(typeof(Link))
+	}
+	
+	public static def getAllInitialTranisitionLinks(Graph g) {
+		g.allLinks.filter[transition instanceof InitialTransition]
+	}
+	
+	public static def getAllTriggeredTranisitionLinks(Graph g) {
+		g.allLinks.filter[transition instanceof TriggeredTransition]
+	}
+	
+	public static def getAllContinuationTranisitionLinks(Graph g) {
+		g.allLinks.filter[transition instanceof ContinuationTransition]
+	}
+	
+	public static def getAllCPBranchTranisitionLinks(Graph g) {
+		g.allLinks.filter[transition instanceof CPBranchTransition]
+	}
+	
+	/**
+	 * returns all links whose transitions are chain heads
+	 * 
+	 * @param g a graph
+	 * @return all deeply contained links that are chain heads
+	 * 
+     * @see #isChainHead(Link))
+	 */
+	public static def getAllChainHeads(Graph g) {
+		g.allLinks.filter[isChainHead]
+	}
+	
+	/**
+	 * @param l a link
+	 * @return {@code true} if the transition associated with this link is a chain head
+	 * 
+     * @see #isChainHead(TransitionBase))
+	 */
+	public static def isChainHead(Link l) {
+		l.transition.isChainHead
+	}
+	
+	/**
+	 * the head of a transition chain is an initial, a guarded or a triggered transition
+	 * 
+	 * @param l a link
+	 * @return {@code true} if this transition is of one of the above types
+	 */
+	public static def boolean isChainHead(TransitionBase t) {
+		if (t instanceof RefinedTransition) {
+			t.target.isChainHead
+		}
+		else {
+			t instanceof InitialTransition ||
+			t instanceof GuardedTransition ||
+			t instanceof TriggeredTransition
+		}
+	}
+	
+	public static def getOutgoingTriggeredTransitionLinks(Node s) {
+		s.outgoing.filter[transition instanceof TriggeredTransition]
+	}
+	
+	public static def getOutgoingTriggeredTransitions(Node s) {
+		s.getOutgoingTriggeredTransitionLinks.map[transition].filter(typeof(TriggeredTransition))
+	}
+	
+	public static def getOutgoingTransitionsHierarchically(Node s) {
+		s.getOutgoingLinksHierarchically.map[transition]
+	}
+	
+	public static def getOutgoingLinksHierarchically(Node s) {
+		val result = newArrayList
+		
+		var current = s
+		while (current!==null) {
+			// outgoing transitions of the state
+			result.addAll(s.outgoing)
+			
+			// outgoing transitions of the transition points of the same level
+			result.addAll(s.graph.transitionPointNodes.map[outgoing].flatten)
+			
+			// ascend to the parent state (iff)
+			current = current.getParentState
+		}
+		
+		return result
+	}
+	
+	public static def isTopLevel(Graph g) {
+		if (g!==null) {
+			g.eContainer instanceof GraphContainer
+		}
+		else true
+	}
+	
+	public static def isEmpty(Graph g) {
+		g===null || (g.nodes.empty && g.links.empty)
+	}
+	
+	public static def isLeaf(Node n) {
+		n.subgraph===null
+	}
+	
+	public static def isTopLevel(Node n) {
+		n.graph.isTopLevel
+	}
+	
+	public static def getParentState(Node n) {
+		if (n.isTopLevel) {
+			null
+		}
+		else {
+			n.graph.eContainer as Node
+		}
+	}
+	
+	public static def getChoicepointDefaultBranch(Node n) {
+		if (!(n.stateGraphNode instanceof ChoicePoint)) {
+			return null
+		}
+		
+		return n.outgoing.filter[transition instanceof ContinuationTransition].head
+	}
+	
+	public static def getParentState(Link l) {
+		if (l.graph.isTopLevel) {
+			null
+		}
+		else {
+			l.graph.eContainer as Node
+		}
+	}
+	
+	public static def isHandler(Link l) {
+		val sourceNode = l.source.stateGraphNode
+		if (sourceNode instanceof TransitionPoint) {
+			sourceNode.isHandler
+		}
+		else {
+			false
+		}
+	}
+	
+	public static def List<DetailCode> getAllDetailCodes(Graph graph) {
+		val detailCodes = <DetailCode>newArrayList
+		
+		if (graph!==null) {
+			val allTransitions = graph.allLinks.map[transition]
+			detailCodes += allTransitions.map[action].toList
+			
+			val allStates = graph.allStateNodes.map[stateGraphNode].filter(typeof(State))
+			detailCodes += allStates.map[entryCode].toList
+			detailCodes += allStates.map[doCode].toList
+			detailCodes += allStates.map[exitCode].toList
+		}
+		
+		return detailCodes
+	}
+	
+	public static def getLinkFor(GraphContainer gc, TransitionBase t) {
+		gc.graph.allLinks.findFirst[transition===t]
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ICommonDataCalculator.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ICommonDataCalculator.java
new file mode 100644
index 000000000..1db60179d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ICommonDataCalculator.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		hrr@protos.de (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+
+public interface ICommonDataCalculator {
+
+	/**
+	 *  calculates the common data of the transition associated with this link.
+	 *  That means all triggers of all transition chain heads of this link are inspected.
+	 *  If one of these has no data, the common data is null.
+	 *  If all of them have a common parent data type (represented as some EObject), then this
+	 *  is taken. If there is no common data type but there are data the link itself is returned
+	 *  with the meaning that there is a generic base type (like Object in Java or void* in C/C++)
+	 * 
+	 *  @param l a link
+	 *  @return an EObject with the meaning as explained above
+	 */
+	EObject calculateCommonData(Link l);
+}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/IDiagnostician.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/IDiagnostician.java
index de0dc86a5..9a9f865b7 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/IDiagnostician.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/IDiagnostician.java
@@ -10,7 +10,7 @@
  * 
  *******************************************************************************/
 
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+package org.eclipse.etrice.core.genmodel.fsm;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/ILogger.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ILogger.java
index 03c53818d..64a6523fc 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/ILogger.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ILogger.java
@@ -10,7 +10,7 @@
  * 
  *******************************************************************************/
 
-package org.eclipse.etrice.core.genmodel.fsm.base;
+package org.eclipse.etrice.core.genmodel.fsm;
 
 import org.eclipse.emf.ecore.EObject;
 
@@ -29,7 +29,17 @@ public interface ILogger {
 	
 	/**
 	 * @param text error text
+	 */
+	void logError(String text);
+	
+	/**
+	 * @param text error text
 	 * @param obj {@link org.eclipse.emf.ecore.EObject EObject} (if available) where the error occurred
 	 */
 	void logError(String text, EObject obj);
+	
+	/**
+	 * returns true if an error occurred
+	 */
+	boolean hasErrors();
 }
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/NullDiagnostician.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/NullDiagnostician.java
index 790b84d79..f67535eb7 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/NullDiagnostician.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/NullDiagnostician.java
@@ -10,11 +10,10 @@
  * 
  *******************************************************************************/
 
-package org.eclipse.etrice.core.genmodel.fsm.base;
+package org.eclipse.etrice.core.genmodel.fsm;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
 
 /**
  * @author Henrik Rentz-Reichert
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/NullLogger.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/NullLogger.java
index 7efce07b7..259f3dca9 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/base/NullLogger.java
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/NullLogger.java
@@ -10,7 +10,7 @@
  * 
  *******************************************************************************/
 
-package org.eclipse.etrice.core.genmodel.fsm.base;
+package org.eclipse.etrice.core.genmodel.fsm;
 
 import org.eclipse.emf.ecore.EObject;
 
@@ -20,6 +20,8 @@ import org.eclipse.emf.ecore.EObject;
  */
 public class NullLogger implements ILogger {
 
+	private int errors = 0;
+	
 	/* (non-Javadoc)
 	 * @see org.eclipse.etrice.core.genmodel.base.ILogger#logInfo(java.lang.String)
 	 */
@@ -32,6 +34,17 @@ public class NullLogger implements ILogger {
 	 */
 	@Override
 	public void logError(String text, EObject obj) {
+		++errors;
+	}
+
+	@Override
+	public void logError(String text) {
+		logError(text, null);
+	}
+
+	@Override
+	public boolean hasErrors() {
+		return errors!=0;
 	}
 
 }
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.xtend b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.xtend
new file mode 100644
index 000000000..ba9422ba4
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.xtend
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm
+
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider
+import com.google.inject.Inject
+import org.eclipse.etrice.core.fsm.fSM.MessageFromIf
+import org.eclipse.etrice.core.fsm.fSM.Trigger
+
+class TriggerExtensions {
+	
+	public static String TRIGGER_SEP = "#"
+	
+	@Inject
+	protected extension FSMNameProvider
+	
+	def getTriggerTag(MessageFromIf it) {
+		from.name + TRIGGER_SEP + message.messageName
+	}
+	
+	def boolean isMatching(Trigger trig, String trigstr) {
+		for (mif : trig.msgFromIfPairs) {
+			val tr = mif.triggerTag
+			if (tr==trigstr)
+				return true
+		}
+		return false
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/builder/FSMGeneratorModelBuilder.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/builder/FSMGeneratorModelBuilder.java
deleted file mode 100644
index 494e45d34..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/builder/FSMGeneratorModelBuilder.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.builder;
-
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class FSMGeneratorModelBuilder {
-
-	private boolean debug = false;
-	private ILogger logger;
-	private IDiagnostician diagnostician;
-
-	/**
-	 * @param nullLogger
-	 * @param diagnostician
-	 */
-	public FSMGeneratorModelBuilder(ILogger logger, IDiagnostician diagnostician) {
-		this.logger = logger;
-		this.diagnostician = diagnostician;
-	}
-
-	/**
-	 * @param mc
-	 * @return
-	 */
-	public ExpandedModelComponent createExpandedModelComponent(ModelComponent mc) {
-		if (debug)
-			logger.logInfo("GeneratorModelBuilder: creating expanded model compoent from "+mc.getComponentName());
-		
-		ExpandedModelComponent xmc = FsmGenFactory.eINSTANCE.createExpandedModelComponent();
-		xmc.setModelComponent(mc);
-		
-		xmc.prepare(diagnostician);
-		
-		return xmc;
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ActiveTrigger.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ActiveTrigger.java
deleted file mode 100644
index 908e1c2c9..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ActiveTrigger.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
-import org.eclipse.etrice.core.fsm.fSM.Guard;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.Trigger;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Active Trigger</b></em>'.
- * It combines information from a transition {@link Trigger} and is meant to represent a trigger which is
- * attached to a {@link State}. The active triggers of a state are computed by collecting all triggers
- * of {@link Transition}s starting at the state. Then transitions starting at {@link TrPoint}s of the parent state
- * are considered. This process is recursively done for all parent states. When a msg/ifitem pair is already
- * in the list of active triggers then further occurrences are skipped except when the first occurrences are
- * {@link Guard}ed.<br/><br/>
- * 
- * The ordered list of active triggers can be obtained from the ExpandedActorClass by calling
- * {@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getActiveTriggers(State) getActiveTriggers(State)}
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getMsg <em>Msg</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getIfitem <em>Ifitem</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTrigger <em>Trigger</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTransitions <em>Transitions</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getActiveTrigger()
- * @model
- * @generated
- */
-public interface ActiveTrigger extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Msg</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * This is the triggering message (in combination with an interface item, cf. {@link #getIfitem()}
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Msg</em>' reference.
-	 * @see #setMsg(EObject)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getActiveTrigger_Msg()
-	 * @model
-	 * @generated
-	 */
-	EObject getMsg();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getMsg <em>Msg</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Msg</em>' reference.
-	 * @see #getMsg()
-	 * @generated
-	 */
-	void setMsg(EObject value);
-
-	/**
-	 * Returns the value of the '<em><b>Ifitem</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * This is the interface item from which the triggering message (see {@link #getMsg()} originates.
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Ifitem</em>' reference.
-	 * @see #setIfitem(AbstractInterfaceItem)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getActiveTrigger_Ifitem()
-	 * @model
-	 * @generated
-	 */
-	AbstractInterfaceItem getIfitem();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getIfitem <em>Ifitem</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Ifitem</em>' reference.
-	 * @see #getIfitem()
-	 * @generated
-	 */
-	void setIfitem(AbstractInterfaceItem value);
-
-	/**
-	 * Returns the value of the '<em><b>Trigger</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * A string representation of the trigger (<b>for internal use only</b>).
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Trigger</em>' attribute.
-	 * @see #setTrigger(String)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getActiveTrigger_Trigger()
-	 * @model
-	 * @generated
-	 */
-	String getTrigger();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTrigger <em>Trigger</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Trigger</em>' attribute.
-	 * @see #getTrigger()
-	 * @generated
-	 */
-	void setTrigger(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Transitions</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.etrice.core.fsm.fSM.TriggeredTransition}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * An ordered list of {@link Transition}s with this trigger.
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Transitions</em>' reference list.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getActiveTrigger_Transitions()
-	 * @model
-	 * @generated
-	 */
-	EList<TriggeredTransition> getTransitions();
-
-} // ActiveTrigger
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedModelComponent.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedModelComponent.java
deleted file mode 100644
index 08d707c34..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedModelComponent.java
+++ /dev/null
@@ -1,342 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
-import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.Trigger;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Expanded Model Component</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getModelComponent <em>Model Component</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getStateMachine <em>State Machine</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getTransitionChains <em>Transition Chains</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedModelComponent()
- * @model
- * @generated
- */
-public interface ExpandedModelComponent extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Model Component</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Model Component</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Model Component</em>' reference.
-	 * @see #setModelComponent(ModelComponent)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedModelComponent_ModelComponent()
-	 * @model
-	 * @generated
-	 */
-	ModelComponent getModelComponent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getModelComponent <em>Model Component</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Model Component</em>' reference.
-	 * @see #getModelComponent()
-	 * @generated
-	 */
-	void setModelComponent(ModelComponent value);
-
-	/**
-	 * Returns the value of the '<em><b>State Machine</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>State Machine</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>State Machine</em>' containment reference.
-	 * @see #setStateMachine(StateGraph)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedModelComponent_StateMachine()
-	 * @model containment="true"
-	 * @generated
-	 */
-	StateGraph getStateMachine();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getStateMachine <em>State Machine</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>State Machine</em>' containment reference.
-	 * @see #getStateMachine()
-	 * @generated
-	 */
-	void setStateMachine(StateGraph value);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model validatorType="org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician"
-	 * @generated
-	 */
-	void prepare(IDiagnostician validator);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	void release();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	void addOwnObject(StateGraphItem obj);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	boolean isOwnObject(StateGraphItem obj);
-
-	/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-    boolean hasBaseTransitionDetailCode(Transition trans);
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	boolean hasStateMachine();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	String getTriggerCodeName(MessageFromIf mif);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	String getTriggerCodeName(ActiveTrigger at);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<Transition> getOutgoingTransitions(StateGraphNode node);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<Transition> getIncomingTransitions(StateGraphNode node);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<ActiveTrigger> getActiveTriggers(State state);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	EList<MessageFromIf> getTriggers();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	EList<MessageFromIf> getOwnTriggers();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	String getMessageID(MessageFromIf mif);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	TransitionChain getChain(Transition trans);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<TransitionChain> getChains(Transition trans);
-
-	/**
-	 * Returns the value of the '<em><b>Transition Chains</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Transition Chains</em>' containment reference list.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedModelComponent_TransitionChains()
-	 * @model containment="true"
-	 * @generated
-	 */
-	EList<TransitionChain> getTransitionChains();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	EList<TransitionChain> getOwnTransitionChains();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<AbstractInterfaceItem> getOwnInterfaceItems(ModelComponent mc);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	EList<AbstractInterfaceItem> getAllInterfaceItems();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	boolean isMatching(Trigger trig, String trigstr);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model outMany="true"
-	 * @generated
-	 */
-	ContinuationTransition getDefaultBranch(EList<Transition> out);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EObject getOrig(EObject copy);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EObject getCopy(EObject orig);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	String getModelComponentName();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EObject getData(Transition trans);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	EList<EObject> getIncomingMessages(AbstractInterfaceItem ifitem);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	TransitionChain addTransitionChain(Transition trans);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	int getInterfaceItemLocalId(AbstractInterfaceItem ifitem);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model chainsMany="true"
-	 * @generated
-	 */
-	EObject computeCommonChainData(EList<TransitionChain> chains);
-
-} // ExpandedModelComponent
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedRefinedState.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedRefinedState.java
deleted file mode 100644
index 074c127c7..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ExpandedRefinedState.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.etrice.core.fsm.fSM.DetailCode;
-import org.eclipse.etrice.core.fsm.fSM.SimpleState;
-import org.eclipse.etrice.core.fsm.fSM.RefinedState;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Expanded Refined State</b></em>'.
- * The expanded refined state is a {@link SimpleState} that additionally holds inherited action codes.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedEntry <em>Inherited Entry</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedExit <em>Inherited Exit</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedDo <em>Inherited Do</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedRefinedState()
- * @model
- * @generated
- */
-public interface ExpandedRefinedState extends SimpleState {
-	/**
-	 * Returns the value of the '<em><b>Inherited Entry</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * This {@link DetailCode} holds the pre-assembled inherited entry code of the original {@link RefinedState} 
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Inherited Entry</em>' containment reference.
-	 * @see #setInheritedEntry(DetailCode)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedRefinedState_InheritedEntry()
-	 * @model containment="true"
-	 * @generated
-	 */
-	DetailCode getInheritedEntry();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedEntry <em>Inherited Entry</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Inherited Entry</em>' containment reference.
-	 * @see #getInheritedEntry()
-	 * @generated
-	 */
-	void setInheritedEntry(DetailCode value);
-
-	/**
-	 * Returns the value of the '<em><b>Inherited Exit</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * This {@link DetailCode} holds the pre-assembled inherited exit code of the original {@link RefinedState} 
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Inherited Exit</em>' containment reference.
-	 * @see #setInheritedExit(DetailCode)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedRefinedState_InheritedExit()
-	 * @model containment="true"
-	 * @generated
-	 */
-	DetailCode getInheritedExit();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedExit <em>Inherited Exit</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Inherited Exit</em>' containment reference.
-	 * @see #getInheritedExit()
-	 * @generated
-	 */
-	void setInheritedExit(DetailCode value);
-
-	/**
-	 * Returns the value of the '<em><b>Inherited Do</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * This {@link DetailCode} holds the pre-assembled inherited do code of the original {@link RefinedState} 
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Inherited Do</em>' containment reference.
-	 * @see #setInheritedDo(DetailCode)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getExpandedRefinedState_InheritedDo()
-	 * @model containment="true"
-	 * @generated
-	 */
-	DetailCode getInheritedDo();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedDo <em>Inherited Do</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Inherited Do</em>' containment reference.
-	 * @see #getInheritedDo()
-	 * @generated
-	 */
-	void setInheritedDo(DetailCode value);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model
-	 * @generated
-	 */
-	void init(RefinedState rs);
-
-} // ExpandedRefinedState
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java
deleted file mode 100644
index bc31edecf..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenFactory.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.emf.ecore.EFactory;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage
- * @generated
- */
-public interface FsmGenFactory extends EFactory {
-	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	FsmGenFactory eINSTANCE = org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenFactoryImpl.init();
-
-	/**
-	 * Returns a new object of class '<em>Active Trigger</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Active Trigger</em>'.
-	 * @generated
-	 */
-	ActiveTrigger createActiveTrigger();
-
-	/**
-	 * Returns a new object of class '<em>Expanded Model Component</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Expanded Model Component</em>'.
-	 * @generated
-	 */
-	ExpandedModelComponent createExpandedModelComponent();
-
-	/**
-	 * Returns a new object of class '<em>Expanded Refined State</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Expanded Refined State</em>'.
-	 * @generated
-	 */
-	ExpandedRefinedState createExpandedRefinedState();
-
-	/**
-	 * Returns a new object of class '<em>Transition Chain</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Transition Chain</em>'.
-	 * @generated
-	 */
-	TransitionChain createTransitionChain();
-
-	/**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the package supported by this factory.
-	 * @generated
-	 */
-	FsmGenPackage getFsmGenPackage();
-
-} //FsmGenFactory
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java
deleted file mode 100644
index 591577612..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/FsmGenPackage.java
+++ /dev/null
@@ -1,720 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
- * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each operation of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
- * </ul>
- * <!-- end-user-doc -->
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory
- * @model kind="package"
- * @generated
- */
-public interface FsmGenPackage extends EPackage {
-	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "fsmgen";
-
-	/**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_URI = "http://www.eclipse.org/etrice/generator/fsm";
-
-	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "fsmgen";
-
-	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	FsmGenPackage eINSTANCE = org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl.init();
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl <em>Active Trigger</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getActiveTrigger()
-	 * @generated
-	 */
-	int ACTIVE_TRIGGER = 0;
-
-	/**
-	 * The feature id for the '<em><b>Msg</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTIVE_TRIGGER__MSG = 0;
-
-	/**
-	 * The feature id for the '<em><b>Ifitem</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTIVE_TRIGGER__IFITEM = 1;
-
-	/**
-	 * The feature id for the '<em><b>Trigger</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTIVE_TRIGGER__TRIGGER = 2;
-
-	/**
-	 * The feature id for the '<em><b>Transitions</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTIVE_TRIGGER__TRANSITIONS = 3;
-
-	/**
-	 * The number of structural features of the '<em>Active Trigger</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTIVE_TRIGGER_FEATURE_COUNT = 4;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl <em>Expanded Model Component</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getExpandedModelComponent()
-	 * @generated
-	 */
-	int EXPANDED_MODEL_COMPONENT = 1;
-
-	/**
-	 * The feature id for the '<em><b>Model Component</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT = 0;
-
-	/**
-	 * The feature id for the '<em><b>State Machine</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_MODEL_COMPONENT__STATE_MACHINE = 1;
-
-	/**
-	 * The feature id for the '<em><b>Transition Chains</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS = 2;
-
-	/**
-	 * The number of structural features of the '<em>Expanded Model Component</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_MODEL_COMPONENT_FEATURE_COUNT = 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl <em>Expanded Refined State</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getExpandedRefinedState()
-	 * @generated
-	 */
-	int EXPANDED_REFINED_STATE = 2;
-
-	/**
-	 * The feature id for the '<em><b>Docu</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__DOCU = FSMPackage.SIMPLE_STATE__DOCU;
-
-	/**
-	 * The feature id for the '<em><b>Entry Code</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__ENTRY_CODE = FSMPackage.SIMPLE_STATE__ENTRY_CODE;
-
-	/**
-	 * The feature id for the '<em><b>Exit Code</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__EXIT_CODE = FSMPackage.SIMPLE_STATE__EXIT_CODE;
-
-	/**
-	 * The feature id for the '<em><b>Do Code</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__DO_CODE = FSMPackage.SIMPLE_STATE__DO_CODE;
-
-	/**
-	 * The feature id for the '<em><b>Subgraph</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__SUBGRAPH = FSMPackage.SIMPLE_STATE__SUBGRAPH;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__NAME = FSMPackage.SIMPLE_STATE__NAME;
-
-	/**
-	 * The feature id for the '<em><b>Inherited Entry</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__INHERITED_ENTRY = FSMPackage.SIMPLE_STATE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Inherited Exit</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__INHERITED_EXIT = FSMPackage.SIMPLE_STATE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Inherited Do</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE__INHERITED_DO = FSMPackage.SIMPLE_STATE_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the '<em>Expanded Refined State</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_REFINED_STATE_FEATURE_COUNT = FSMPackage.SIMPLE_STATE_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link IDiagnostician <em>IDiagnostician</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see IDiagnostician
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getIDiagnostician()
-	 * @generated
-	 */
-	int IDIAGNOSTICIAN = 3;
-
-	/**
-	 * The number of structural features of the '<em>IDiagnostician</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IDIAGNOSTICIAN_FEATURE_COUNT = 0;
-
-	/**
-	 * The meta object id for the '{@link ITransitionChainVisitor <em>ITransition Chain Visitor</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see ITransitionChainVisitor
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getITransitionChainVisitor()
-	 * @generated
-	 */
-	int ITRANSITION_CHAIN_VISITOR = 4;
-
-	/**
-	 * The number of structural features of the '<em>ITransition Chain Visitor</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ITRANSITION_CHAIN_VISITOR_FEATURE_COUNT = 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl <em>Transition Chain</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getTransitionChain()
-	 * @generated
-	 */
-	int TRANSITION_CHAIN = 5;
-
-	/**
-	 * The feature id for the '<em><b>Transition</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TRANSITION_CHAIN__TRANSITION = 0;
-
-	/**
-	 * The feature id for the '<em><b>Data</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TRANSITION_CHAIN__DATA = 1;
-
-	/**
-	 * The number of structural features of the '<em>Transition Chain</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TRANSITION_CHAIN_FEATURE_COUNT = 2;
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger <em>Active Trigger</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Active Trigger</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger
-	 * @generated
-	 */
-	EClass getActiveTrigger();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getMsg <em>Msg</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Msg</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getMsg()
-	 * @see #getActiveTrigger()
-	 * @generated
-	 */
-	EReference getActiveTrigger_Msg();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getIfitem <em>Ifitem</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Ifitem</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getIfitem()
-	 * @see #getActiveTrigger()
-	 * @generated
-	 */
-	EReference getActiveTrigger_Ifitem();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTrigger <em>Trigger</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Trigger</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTrigger()
-	 * @see #getActiveTrigger()
-	 * @generated
-	 */
-	EAttribute getActiveTrigger_Trigger();
-
-	/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTransitions <em>Transitions</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Transitions</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger#getTransitions()
-	 * @see #getActiveTrigger()
-	 * @generated
-	 */
-	EReference getActiveTrigger_Transitions();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent <em>Expanded Model Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Expanded Model Component</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-	 * @generated
-	 */
-	EClass getExpandedModelComponent();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getModelComponent <em>Model Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Model Component</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getModelComponent()
-	 * @see #getExpandedModelComponent()
-	 * @generated
-	 */
-	EReference getExpandedModelComponent_ModelComponent();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getStateMachine <em>State Machine</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>State Machine</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getStateMachine()
-	 * @see #getExpandedModelComponent()
-	 * @generated
-	 */
-	EReference getExpandedModelComponent_StateMachine();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getTransitionChains <em>Transition Chains</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Transition Chains</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent#getTransitionChains()
-	 * @see #getExpandedModelComponent()
-	 * @generated
-	 */
-	EReference getExpandedModelComponent_TransitionChains();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState <em>Expanded Refined State</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Expanded Refined State</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState
-	 * @generated
-	 */
-	EClass getExpandedRefinedState();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedEntry <em>Inherited Entry</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Inherited Entry</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedEntry()
-	 * @see #getExpandedRefinedState()
-	 * @generated
-	 */
-	EReference getExpandedRefinedState_InheritedEntry();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedExit <em>Inherited Exit</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Inherited Exit</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedExit()
-	 * @see #getExpandedRefinedState()
-	 * @generated
-	 */
-	EReference getExpandedRefinedState_InheritedExit();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedDo <em>Inherited Do</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Inherited Do</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState#getInheritedDo()
-	 * @see #getExpandedRefinedState()
-	 * @generated
-	 */
-	EReference getExpandedRefinedState_InheritedDo();
-
-	/**
-	 * Returns the meta object for class '{@link IDiagnostician <em>IDiagnostician</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>IDiagnostician</em>'.
-	 * @see IDiagnostician
-	 * @model instanceClass="IDiagnostician"
-	 * @generated
-	 */
-	EClass getIDiagnostician();
-
-	/**
-	 * Returns the meta object for class '{@link ITransitionChainVisitor <em>ITransition Chain Visitor</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>ITransition Chain Visitor</em>'.
-	 * @see ITransitionChainVisitor
-	 * @model instanceClass="ITransitionChainVisitor"
-	 * @generated
-	 */
-	EClass getITransitionChainVisitor();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain <em>Transition Chain</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Transition Chain</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain
-	 * @generated
-	 */
-	EClass getTransitionChain();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getTransition <em>Transition</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Transition</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getTransition()
-	 * @see #getTransitionChain()
-	 * @generated
-	 */
-	EReference getTransitionChain_Transition();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getData <em>Data</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Data</em>'.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getData()
-	 * @see #getTransitionChain()
-	 * @generated
-	 */
-	EReference getTransitionChain_Data();
-
-	/**
-	 * Returns the factory that creates the instances of the model.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the factory that creates the instances of the model.
-	 * @generated
-	 */
-	FsmGenFactory getFsmGenFactory();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * Defines literals for the meta objects that represent
-	 * <ul>
-	 *   <li>each class,</li>
-	 *   <li>each feature of each class,</li>
-	 *   <li>each operation of each class,</li>
-	 *   <li>each enum,</li>
-	 *   <li>and each data type</li>
-	 * </ul>
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	interface Literals {
-		/**
-		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl <em>Active Trigger</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ActiveTriggerImpl
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getActiveTrigger()
-		 * @generated
-		 */
-		EClass ACTIVE_TRIGGER = eINSTANCE.getActiveTrigger();
-
-		/**
-		 * The meta object literal for the '<em><b>Msg</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ACTIVE_TRIGGER__MSG = eINSTANCE.getActiveTrigger_Msg();
-
-		/**
-		 * The meta object literal for the '<em><b>Ifitem</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ACTIVE_TRIGGER__IFITEM = eINSTANCE.getActiveTrigger_Ifitem();
-
-		/**
-		 * The meta object literal for the '<em><b>Trigger</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute ACTIVE_TRIGGER__TRIGGER = eINSTANCE.getActiveTrigger_Trigger();
-
-		/**
-		 * The meta object literal for the '<em><b>Transitions</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ACTIVE_TRIGGER__TRANSITIONS = eINSTANCE.getActiveTrigger_Transitions();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl <em>Expanded Model Component</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getExpandedModelComponent()
-		 * @generated
-		 */
-		EClass EXPANDED_MODEL_COMPONENT = eINSTANCE.getExpandedModelComponent();
-
-		/**
-		 * The meta object literal for the '<em><b>Model Component</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT = eINSTANCE.getExpandedModelComponent_ModelComponent();
-
-		/**
-		 * The meta object literal for the '<em><b>State Machine</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_MODEL_COMPONENT__STATE_MACHINE = eINSTANCE.getExpandedModelComponent_StateMachine();
-
-		/**
-		 * The meta object literal for the '<em><b>Transition Chains</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS = eINSTANCE.getExpandedModelComponent_TransitionChains();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl <em>Expanded Refined State</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getExpandedRefinedState()
-		 * @generated
-		 */
-		EClass EXPANDED_REFINED_STATE = eINSTANCE.getExpandedRefinedState();
-
-		/**
-		 * The meta object literal for the '<em><b>Inherited Entry</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_REFINED_STATE__INHERITED_ENTRY = eINSTANCE.getExpandedRefinedState_InheritedEntry();
-
-		/**
-		 * The meta object literal for the '<em><b>Inherited Exit</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_REFINED_STATE__INHERITED_EXIT = eINSTANCE.getExpandedRefinedState_InheritedExit();
-
-		/**
-		 * The meta object literal for the '<em><b>Inherited Do</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference EXPANDED_REFINED_STATE__INHERITED_DO = eINSTANCE.getExpandedRefinedState_InheritedDo();
-
-		/**
-		 * The meta object literal for the '{@link IDiagnostician <em>IDiagnostician</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see IDiagnostician
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getIDiagnostician()
-		 * @generated
-		 */
-		EClass IDIAGNOSTICIAN = eINSTANCE.getIDiagnostician();
-
-		/**
-		 * The meta object literal for the '{@link ITransitionChainVisitor <em>ITransition Chain Visitor</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see ITransitionChainVisitor
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getITransitionChainVisitor()
-		 * @generated
-		 */
-		EClass ITRANSITION_CHAIN_VISITOR = eINSTANCE.getITransitionChainVisitor();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl <em>Transition Chain</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl
-		 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.FsmGenPackageImpl#getTransitionChain()
-		 * @generated
-		 */
-		EClass TRANSITION_CHAIN = eINSTANCE.getTransitionChain();
-
-		/**
-		 * The meta object literal for the '<em><b>Transition</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference TRANSITION_CHAIN__TRANSITION = eINSTANCE.getTransitionChain_Transition();
-
-		/**
-		 * The meta object literal for the '<em><b>Data</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference TRANSITION_CHAIN__DATA = eINSTANCE.getTransitionChain_Data();
-
-	}
-
-} //FsmGenPackage
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/TransitionChain.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/TransitionChain.java
deleted file mode 100644
index e2e4d1279..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/TransitionChain.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
-
-import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Transition Chain</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getTransition <em>Transition</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getData <em>Data</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getTransitionChain()
- * @model
- * @generated
- */
-public interface TransitionChain extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Transition</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Transition</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Transition</em>' reference.
-	 * @see #setTransition(Transition)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getTransitionChain_Transition()
-	 * @model
-	 * @generated
-	 */
-	Transition getTransition();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getTransition <em>Transition</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Transition</em>' reference.
-	 * @see #getTransition()
-	 * @generated
-	 */
-	void setTransition(Transition value);
-
-	/**
-	 * Returns the value of the '<em><b>Data</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Data</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Data</em>' reference.
-	 * @see #setData(EObject)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#getTransitionChain_Data()
-	 * @model
-	 * @generated
-	 */
-	EObject getData();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain#getData <em>Data</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Data</em>' reference.
-	 * @see #getData()
-	 * @generated
-	 */
-	void setData(EObject value);
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	State getStateContext();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	boolean isHandler();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model tcvType="org.eclipse.etrice.core.genmodel.fsm.fsmgen.ITransitionChainVisitor"
-	 * @generated
-	 */
-	String genExecuteChain(ITransitionChainVisitor tcv);
-
-} // TransitionChain
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedModelComponentImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedModelComponentImpl.java
deleted file mode 100644
index 5d60c3b09..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedModelComponentImpl.java
+++ /dev/null
@@ -1,1410 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map.Entry;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.common.util.TreeIterator;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EcoreUtil.Copier;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType;
-import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.DetailCode;
-import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
-import org.eclipse.etrice.core.fsm.fSM.ExitPoint;
-import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.fsm.fSM.GuardedTransition;
-import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.RefinedState;
-import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.StateTerminal;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TransitionPoint;
-import org.eclipse.etrice.core.fsm.fSM.Trigger;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Expanded Actor Class</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getModelComponent <em>Model Component</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getStateMachine <em>State Machine</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getTransitionChains <em>Transition Chains</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ExpandedModelComponentImpl extends MinimalEObjectImpl.Container implements ExpandedModelComponent {
-	
-	/**
-	 * The cached value of the '{@link #getModelComponent() <em>Model Component</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getModelComponent()
-	 * @generated
-	 * @ordered
-	 */
-	protected ModelComponent modelComponent;
-
-	private static class NodeData {
-		private LinkedList<Transition> inTrans = new LinkedList<Transition>();
-		private LinkedList<Transition> outTrans = new LinkedList<Transition>();
-		private LinkedList<Transition> loopTrans = null;
-
-		LinkedList<Transition> getInTrans() {
-			return inTrans;
-		}
-
-		LinkedList<Transition> getOutTrans() {
-			return outTrans;
-		}
-
-		LinkedList<Transition> getLoopTransitions() {
-			if (loopTrans==null) {
-				loopTrans = new LinkedList<Transition>();
-				for (Transition t : getOutTrans()) {
-					// outgoing transitions always are NonInitialTransitions
-					NonInitialTransition tr = (NonInitialTransition) t;
-					
-					if (tr.getFrom() instanceof StateTerminal) {
-						if (tr.getTo() instanceof StateTerminal) {
-							if (((StateTerminal)tr.getFrom()).getState() == ((StateTerminal)tr.getTo()).getState())
-								loopTrans.add(tr);
-						}
-					}
-					else if (tr.getFrom() instanceof TrPointTerminal) {
-						if (tr.getTo() instanceof TrPointTerminal) {
-							if (((TrPointTerminal)tr.getFrom()).getTrPoint() == ((TrPointTerminal)tr.getTo()).getTrPoint())
-								loopTrans.add(tr);
-						}
-					}
-				}
-			}
-			return loopTrans;
-		}
-	}
-
-	/**
-	 * transition chains may merge in a choice point or in an entry or exit point.
-	 * We call all merged transition chains a transition chain bundle
-	 *
-	 */
-	protected static class TransitionChainBundle {
-		private BasicEList<TransitionChain> chains = new BasicEList<TransitionChain>();
-		private EObject commonData = null;
-	}
-	
-	protected class TransitionToChainBundleMap extends HashMap<Transition, TransitionChainBundle> {
-		private static final long serialVersionUID = 1L;
-
-		void put(Transition t, TransitionChain tc) {
-			TransitionChainBundle tcb = get(t);
-			if (tcb==null) {
-				tcb = new TransitionChainBundle();
-				put(t, tcb);
-			}
-			tcb.chains.add(tc);
-		}
-		
-		/* (non-Javadoc)
-		 * @see java.util.AbstractMap#toString()
-		 */
-//		@Override
-//		public String toString() {
-//			StringBuffer result = new StringBuffer();
-//			for (java.util.Map.Entry<Transition, TransitionChainBundle> entry : entrySet()) {
-//				result.append("transition "+fsmNameProvider.getFullPath(entry.getKey())+":\n");
-//				TransitionChainBundle bundle = entry.getValue();
-//				for (TransitionChain tc : bundle.chains) {
-//					String data = tc.getData()!=null? " with data "+tc.getData().getRefType().getType().getName() : "";
-//					result.append("  chain starting at "+fsmNameProvider.getFullPath(tc.getTransition())+data+"\n");
-//				}
-//				String data = bundle.commonData!=null? bundle.commonData.getRefType().getType().getName() : "-";
-//				result.append("  bundle data "+data+"\n");
-//			}
-//			return result.toString();
-//		}
-	}
-	
-	/**
-	 * The cached value of the '{@link #getStateMachine() <em>State Machine</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getStateMachine()
-	 * @generated
-	 * @ordered
-	 */
-	protected StateGraph stateMachine;
-
-	/**
-	 * The cached value of the '{@link #getTransitionChains() <em>Transition Chains</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTransitionChains()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList<TransitionChain> transitionChains;
-
-	private static final String TRIGGER_SEP = "#";
-	
-	private IDiagnostician validator;
-
-	private boolean prepared = false;
-	private HashSet<StateGraphItem> ownObjects = null;
-	private HashSet<Transition> targetsOfRefinedTransitions = null;
-    private HashSet<Transition> baseTransitionHasDetailCode = null;
-	private HashMap<AbstractInterfaceItem, Integer> ifitem2localId = null;
-	private HashMap<StateGraphNode, NodeData> node2data = null;
-	private HashMap<State, LinkedList<ActiveTrigger>> state2triggers = null;
-	private HashMap<String, MessageFromIf> triggerstring2mif = null;
-	private TransitionToChainBundleMap trans2chainBundle = null;
-	private HashMap<EObject, EObject> copy2orig = null;
-	private HashMap<EObject, EObject> orig2copy = null;
-	
-	private FSMHelpers fsmHelpers = new FSMHelpers();
-	protected FSMNameProvider fsmNameProvider = new FSMNameProvider();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExpandedModelComponentImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return FsmGenPackage.Literals.EXPANDED_MODEL_COMPONENT;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ModelComponent getModelComponent() {
-		if (modelComponent != null && modelComponent.eIsProxy()) {
-			InternalEObject oldModelComponent = (InternalEObject)modelComponent;
-			modelComponent = (ModelComponent)eResolveProxy(oldModelComponent);
-			if (modelComponent != oldModelComponent) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT, oldModelComponent, modelComponent));
-			}
-		}
-		return modelComponent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ModelComponent basicGetModelComponent() {
-		return modelComponent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setModelComponent(ModelComponent newModelComponent) {
-		ModelComponent oldModelComponent = modelComponent;
-		modelComponent = newModelComponent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT, oldModelComponent, modelComponent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public StateGraph getStateMachine() {
-		return stateMachine;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetStateMachine(StateGraph newStateMachine, NotificationChain msgs) {
-		StateGraph oldStateMachine = stateMachine;
-		stateMachine = newStateMachine;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE, oldStateMachine, newStateMachine);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setStateMachine(StateGraph newStateMachine) {
-		if (newStateMachine != stateMachine) {
-			NotificationChain msgs = null;
-			if (stateMachine != null)
-				msgs = ((InternalEObject)stateMachine).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE, null, msgs);
-			if (newStateMachine != null)
-				msgs = ((InternalEObject)newStateMachine).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE, null, msgs);
-			msgs = basicSetStateMachine(newStateMachine, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE, newStateMachine, newStateMachine));
-	}
-
-	protected void validationError(String msg, EObject obj, EStructuralFeature feature) {
-		validationError(msg, obj, feature, IDiagnostician.INSIGNIFICANT_INDEX);
-	}
-	
-	protected void validationError(String msg, EObject obj, EStructuralFeature feature, int idx) {
-//		assert obj.eResource() != null : "val error in artificial model object";
-		if (obj.eResource()==null) {
-			obj = copy2orig.get(obj);
-		}
-		validator.error(msg, obj, feature, idx);
-	}
-	
-	private void buildStateGraph() {
-		// create a list of state machines, derived first, base last
-		ArrayList<StateGraph> stateMachines = new ArrayList<StateGraph>();
-		ModelComponent orig = getModelComponent();
-		if (orig.getStateMachine()!=null)
-			stateMachines.add(orig.getStateMachine());
-		while (orig.getBase()!=null) {
-			orig = orig.getBase();
-			if (orig.getStateMachine()!=null)
-				stateMachines.add(orig.getStateMachine());
-		}
-		
-		Collection<StateGraph> copiedStateMachines = createCopyOfStateMachines(stateMachines);
-		
-		collectContentsInNewStateMachine(copiedStateMachines);
-		
-		introduceExpandedRefinedStates(getStateMachine());
-	}
-
-	private void collectContentsInNewStateMachine(Collection<StateGraph> copiedStateMachines) {
-		// move all state machine contents to our state machine (which we create newly)
-		StateGraph myStateMachine = FSMFactory.eINSTANCE.createStateGraph();
-		setStateMachine(myStateMachine);
-
-		HashMap<Transition, DetailCode> trans2refinedAction = new HashMap<Transition, DetailCode>();
-		for (StateGraph copiedStateMachine : copiedStateMachines) {
-			myStateMachine.getChPoints().addAll(copiedStateMachine.getChPoints());
-			myStateMachine.getStates().addAll(copiedStateMachine.getStates());
-			myStateMachine.getTrPoints().addAll(copiedStateMachine.getTrPoints());
-			myStateMachine.getTransitions().addAll(copiedStateMachine.getTransitions());
-			
-			// collect the refined action code in a hash map
-			for (RefinedTransition rt : copiedStateMachine.getRefinedTransitions()) {
-				if (rt.getAction()==null || rt.getAction().getLines().isEmpty())
-					continue;
-				
-				DetailCode code = trans2refinedAction.get(rt.getTarget());
-				if (code==null) {
-					code = FSMFactory.eINSTANCE.createDetailCode();
-					trans2refinedAction.put(rt.getTarget(), code);
-				}
-				
-				code.getLines().addAll(0, rt.getAction().getLines());
-				code.setUsed(fsmHelpers.hasDetailCode(code));
-			}
-		}
-		
-		// for refined transitions we just append the action code to the target
-		// we can do this since the target is a copy just for this class
-		for (Entry<Transition, DetailCode> entry : trans2refinedAction.entrySet()) {
-			ownObjects.add(entry.getKey());
-			targetsOfRefinedTransitions.add(entry.getKey());
-			if (entry.getKey().getAction()==null) {
-			    entry.getKey().setAction(entry.getValue());
-			}
-			else {
-			    baseTransitionHasDetailCode.add(entry.getKey());
-			    entry.getKey().getAction().getLines().addAll(entry.getValue().getLines());
-			}
-		}
-	}
-
-	private Collection<StateGraph> createCopyOfStateMachines(List<StateGraph> origStateMachines) {
-		// create a self contained copy of all actor classes
-		// references to interface items (ports, saps and spps) point to contents of the original actor class
-		// Collection<StateGraph> all = EcoreUtil.copyAll(sms);
-		// we use the copier directly since we need access to the map
-		Copier copier = new Copier();
-	    Collection<StateGraph> copiedStateMachines = copier.copyAll(origStateMachines);
-	    copier.copyReferences();
-	    for (EObject o : copier.keySet()) {
-			EObject c = copier.get(o);
-			copy2orig.put(c, o);
-			orig2copy.put(o, c);
-		}
-		
-	    if (getModelComponent().getStateMachine()!=null) {
-	    	// first state machine is ours
-	    	StateGraph self = copiedStateMachines.iterator().next();
-	    	
-	    	// flag own objects
-			TreeIterator<EObject> it = self.eAllContents();
-			while (it.hasNext()) {
-				EObject obj = it.next();
-				if (obj instanceof StateGraphItem)
-					addOwnObject((StateGraphItem)obj);
-			}
-	    }
-		return copiedStateMachines;
-	}
-
-	/**
-	 * replace refined state with a ExpandedRefinedState but as replacement of the ultimate SimpleState
-	 * the refined state is targeting
-	 * 
-	 * @param sg - the current context (will be called recursively)
-	 */
-	private void introduceExpandedRefinedStates(StateGraph sg) {
-		// need to make a copy of the list because we will modify the original list
-		ArrayList<State> states = new ArrayList<State>(sg.getStates());
-		for (State s : states) {
-			if (s instanceof RefinedState) {
-				RefinedState rs = (RefinedState) s;
-				
-				ExpandedRefinedState state = FsmGenFactory.eINSTANCE.createExpandedRefinedState();
-				state.init(rs);
-				copy2orig.put(state, getOrig(rs));
-				orig2copy.put(getOrig(rs), state);
-				if (isOwnObject(rs))
-					addOwnObject(state);
-			}
-		}
-		
-		// recurse down into sub graph
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				introduceExpandedRefinedStates(s.getSubgraph());
-		}
-	}
-	
-	private void addOutgoingTransition(StateGraphNode node, Transition t) {
-		NodeData data = node2data.get(node);
-		if (data==null) {
-			data = new NodeData();
-			node2data.put(node, data);
-		}
-		data.getOutTrans().add(t);
-	}
-	
-	private void addIncomingTransition(StateGraphNode node, Transition t) {
-		NodeData data = node2data.get(node);
-		if (data==null) {
-			data = new NodeData();
-			node2data.put(node, data);
-		}
-		data.getInTrans().add(t);
-	}
-	
-	private void findOutgoingTransitions(StateGraph sg) {
-		// depth first: recurse into sub graphs of states
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				findOutgoingTransitions(s.getSubgraph());
-		}
-
-		for (Transition t : sg.getTransitions()) {
-			addIncomingTransition(getAdjustedTargetNode(t), t);
-			if (t instanceof NonInitialTransition) {
-				addOutgoingTransition(fsmHelpers.getNode(((NonInitialTransition)t).getFrom()), t);
-			}
-		}
-	}
-
-	/**
-	 * @param sg
-	 */
-	private void checkTransitionChains(StateGraph sg) {
-		for (Transition t : sg.getTransitions()) {
-			TransitionChain chain = getChain(t);
-			if (chain==null)
-				if (!getModelComponent().isAbstract()) {
-					int idx = sg.getTransitions().indexOf(t);
-					Transition orig = (Transition) copy2orig.get(t);
-					String name = fsmNameProvider.getName(orig);
-					validator.error("transition '"+name+"' is not part of a transition chain (only allowed for abstract actor classes)", orig.eContainer(), FSMPackage.eINSTANCE.getStateGraph_Transitions(), idx);
-				}
-		}
-		
-		// recursion
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				checkTransitionChains(s.getSubgraph());
-		}
-	}
-	
-	private void doChecks(StateGraph sg) {
-		
-		// check if empty
-		if (sg.getTransitions().isEmpty() && sg.getStates().isEmpty()
-				&& sg.getChPoints().isEmpty() && sg.getTrPoints().isEmpty())
-			return;
-		
-		int initCount = 0;
-		for (Transition t : sg.getTransitions()) {
-			if (t instanceof InitialTransition)
-				++initCount;
-		}
-		if (initCount==0) {
-			if (sg.eContainer() instanceof State) {
-				if (!getModelComponent().isAbstract()) {
-					// having no initial transition in a nested state is valid only if there is no transition to history
-					// except of self transitions
-					// i.e. no incoming transition of the state itself
-					NodeData data = node2data.get((State)sg.eContainer());
-					if (data!=null && data.getLoopTransitions().size()!=data.getInTrans().size())
-						validationError(getModelComponentName()+": Having no initial transition in a nested state is valid only if there is no transition to history except of self transitions!",
-								sg.eContainer(), FSMPackage.eINSTANCE.getState_Subgraph());
-				}
-			}
-			else {
-				validationError(getModelComponentName()+": The TOP level has to have an initial transition!", getModelComponent().getStateMachine(), FSMPackage.eINSTANCE.getStateGraph_Transitions());
-			}
-		}
-		else {
-			if (initCount>1)
-				validationError(getModelComponentName()+": There has to be exactly one initial transition!", getModelComponent().getStateMachine(), FSMPackage.eINSTANCE.getStateGraph_Transitions());
-		}
-		
-		for (ChoicePoint cp : sg.getChPoints()) {
-			NodeData data = node2data.get(cp);
-			
-			ChoicePoint orig = (ChoicePoint) copy2orig.get(cp);
-			StateGraph origContainer = (StateGraph) orig.eContainer();
-			int idx = origContainer.getChPoints().indexOf(orig);
-			
-			if (data==null) {
-				validationError(getModelComponentName()+": ChoicePoint is not connected!", origContainer, FSMPackage.eINSTANCE.getStateGraph_ChPoints(), idx);
-			}
-			else {
-				// several incoming transitions possible, see bug 340496
-//				if (data.getInTrans().size()!=1)
-//					validationError(getModelComponentName()+": ChoicePoint has "+data.getInTrans().size()+" incoming transitions!", sg, FSMPackage.eINSTANCE.getStateGraph_ChPoints(), idx);
-				if (data.getOutTrans().size()<2)
-					validationError(getModelComponentName()+": ChoicePoint should have 2 or more branches but has "+data.getOutTrans().size(), origContainer, FSMPackage.eINSTANCE.getStateGraph_ChPoints(), idx);
-				if (getDefaultBranch(data.getOutTrans())==null)
-					validationError(getModelComponentName()+": ChoicePoint has no default branch!", origContainer, FSMPackage.eINSTANCE.getStateGraph_ChPoints(), idx);
-				if (!data.getLoopTransitions().isEmpty())
-					validationError(getModelComponentName()+": ChoicePoint is connected to itself!", origContainer, FSMPackage.eINSTANCE.getStateGraph_ChPoints(), idx);
-			}
-		}
-		
-		for (TrPoint tp : sg.getTrPoints()) {
-			NodeData data = node2data.get(tp);
-			
-			TrPoint orig = (TrPoint) copy2orig.get(tp);
-			StateGraph origContainer = (StateGraph) orig.eContainer();
-			int idx = origContainer.getTrPoints().indexOf(orig);
-			
-			if (data==null) {
-				if (!getModelComponent(tp).isAbstract())
-					validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" is not connected", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-			}
-			else {
-				if ((tp instanceof EntryPoint)||(tp instanceof ExitPoint)) {
-					// non-abstract classes must have incoming transitions for entry and exit points
-					if (!getModelComponent().isAbstract() && data.getInTrans().isEmpty())
-						validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" has no incoming transition!", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-					
-					if (getModelComponent(tp).isAbstract()) {
-						// transition points inherited from abstract base classes
-						// (of from abstract classes themselves) must not have more than one outgoing transition
-						if (data.getOutTrans().size()>1)
-							validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" must have at most one outgoing transition!", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-					}
-					else {
-						// non-abstract or non-inherited transition points must have one outgoing transition
-						if (data.getOutTrans().size()!=1)
-							validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" must have exactly one outgoing transition!", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-					}
-					
-					if (!data.getLoopTransitions().isEmpty())
-						validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" must have no self transitions!", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-				}
-				else if (tp instanceof TransitionPoint) {
-					if (data.getOutTrans().size()<data.getLoopTransitions().size())
-						validationError(getModelComponentName()+": TrPoint "+fsmNameProvider.getFullPath(tp)+" must have no incoming transitions!", origContainer, FSMPackage.eINSTANCE.getStateGraph_TrPoints(), idx);
-				}
-			}
-		}
-		
-		// recurse into sub graphs of states
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				doChecks(s.getSubgraph());
-		}
-	}
-	
-	private void findTriggersOfState(State s) {
-		LinkedList<ActiveTrigger> triggers = new LinkedList<ActiveTrigger>();
-		HashMap<String, ActiveTrigger> caughtTriggers = new HashMap<String, ActiveTrigger>();
-		collectTriggersAndTransitions(s, caughtTriggers, triggers);
-		state2triggers.put(s, triggers);
-	}
-	
-	private String getTriggerString(MessageFromIf mifp) {
-		assert(mifp.getFrom().getName()!=null) : "ifitem name must not be null";
-		assert(fsmNameProvider.getMessageName(mifp.getMessage())!=null) : "message name must not be null";
-		return mifp.getFrom().getName()+TRIGGER_SEP+fsmNameProvider.getMessageName(mifp.getMessage());
-	}
-
-	private void collectOutgoingTransitions(EList<Transition> sameLevelTransitions,
-			HashMap<String, ActiveTrigger> caughtTriggers,
-			LinkedList<ActiveTrigger> triggers) {
-		for (Transition t : sameLevelTransitions) {
-			if (t instanceof TriggeredTransition) {
-				TriggeredTransition tt = (TriggeredTransition) t;
-				
-				for (Trigger trig : ((TriggeredTransition)t).getTriggers()) {
-					for (MessageFromIf mifp : trig.getMsgFromIfPairs()) {
-						String tr = getTriggerString(mifp);
-						ActiveTrigger at = caughtTriggers.get(tr);
-						/*
-						 * accept new trigger if
-						 * 
-						 *  - no inner or inner with guard
-						 *  - accept several but only one without guard (count),
-						 *    insert those with guard first in the list of the _same_ level(!)
-						 */
-						if (at==null) {
-							// no inner transition with this trigger exists,
-							// so this is a new trigger (and our unique point of ActiveTrigger creation)
-							at = FsmGenFactory.eINSTANCE.createActiveTrigger();
-							at.setMsg(mifp.getMessage());
-							at.setIfitem(mifp.getFrom());
-							at.setTrigger(tr);
-							at.getTransitions().add(tt);
-							caughtTriggers.put(tr, at);
-							triggers.add(at);
-						}
-						else {
-							// check guards of previous transitions
-							TriggeredTransition unguarded = null;
-							boolean accepted = true;
-							for (TriggeredTransition t2 : at.getTransitions()) {
-								for (Trigger trig2 : t2.getTriggers()) {
-									if (isMatching(trig2, tr)) {
-										if (!fsmHelpers.isGuarded(trig2)) {
-											unguarded = t2;
-											if (!sameLevelTransitions.contains(t2))
-												accepted = false;
-										}
-									}
-								}
-							}
-							if (accepted) {
-								if (unguarded!=null) {
-									// there already is an unguarded transition: require a quard
-									if (!fsmHelpers.isGuarded(trig)) {
-										validationError("Transitions with same trigger on same level have to be guarded!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-									}
-									else {
-										int idx = at.getTransitions().indexOf(unguarded);
-										at.getTransitions().add(idx, tt);
-									}
-								}
-								else {
-									// just add at the end
-									at.getTransitions().add(tt);
-								}
-							}
-							// else: this trigger is already satisfied - nevertheless this is a valid situation
-						}
-					}
-				}
-			}
-		}
-	}
-
-	private void collectTriggersAndTransitions(State s,
-			HashMap<String, ActiveTrigger> caughtTriggers,
-			LinkedList<ActiveTrigger> triggers) {
-		// consider outgoing transitions of this state
-		collectOutgoingTransitions(getOutgoingTransitions(s), caughtTriggers, triggers);
-		
-		// consider TransitionPoint transitions
-		if (s.eContainer() instanceof StateGraph) {
-			StateGraph sg = (StateGraph) s.eContainer();
-			BasicEList<Transition> trpTransitions = new BasicEList<Transition>();
-			for (TrPoint tp : sg.getTrPoints()) {
-				trpTransitions.addAll(getOutgoingTransitions(tp));
-			}
-			collectOutgoingTransitions(trpTransitions, caughtTriggers, triggers);
-			
-			// go to surrounding context
-			if (sg.eContainer() instanceof State) {
-				collectTriggersAndTransitions((State) sg.eContainer(), caughtTriggers, triggers);
-			}
-		}
-		else {
-			// this should never happen
-			assert(false): "A State must always reside in a StateGraph!";
-		}
-	}
-
-	private void findLeafStateTriggers(StateGraph sg) {
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				findLeafStateTriggers(s.getSubgraph());
-			else
-				findTriggersOfState(s);
-		}
-	}
-
-	private void fillTriggerStringMap() {
-		// improve performance using maps name2ifitem and name2msgs
-		HashMap<String, AbstractInterfaceItem> name2ifitem = new HashMap<String, AbstractInterfaceItem>();
-		HashMap<String, List<EObject>> name2msgs = new HashMap<String, List<EObject>>();
-		List<AbstractInterfaceItem> items = getAllInterfaceItems();
-		for (AbstractInterfaceItem item : items) {
-			name2ifitem.put(item.getName(), item);
-			name2msgs.put(item.getName(), getIncomingMessages(item));      								
-		}
-		
-		// compute a set of all trigger strings
-		HashSet<String> triggers = new HashSet<String>();
-		for (LinkedList<ActiveTrigger> ttlist : state2triggers.values()) {
-			for (ActiveTrigger tt : ttlist) {
-				triggers.add(tt.getTrigger());
-			}
-		}
-		
-		// now fill triggerstring2mif
-		for (String trig : triggers) {
-			String[] parts = trig.split(TRIGGER_SEP);
-			
-			// this should always hold true
-			assert(parts.length==2): "By our convention triggers are composed of two parts separated by "
-				+TRIGGER_SEP+". Here we have '"+trig+"' which doesn't consist of two parts!";
-			
-			AbstractInterfaceItem ii = name2ifitem.get(parts[0]);
-			
-			// this should always hold true
-			assert(ii!=null): "The name '"+parts[0]+"' did not match an interface item (in name2ifitem)!";
-
-			List<EObject> msgs = name2msgs.get(parts[0]);
-			
-			// this should always hold true
-			assert(msgs!=null): "The name '"+parts[0]+"' did not match an interface item (in name2msgs)!";
-
-			EObject msg = null;
-			for (EObject m : msgs) {
-				if (fsmNameProvider.getMessageName(m).equals(parts[1]))
-					msg  = m;
-			}
-			
-			// this should always hold true
-			assert(msg!=null): "The message '"+parts[1]+"' did not match a message!";
-			
-			MessageFromIf mif = FSMFactory.eINSTANCE.createMessageFromIf();
-			mif.setFrom(ii);
-			mif.setMessage(msg);
-			triggerstring2mif.put(trig, mif);
-		}
-	}
-
-	private void collectChainTransitions(TransitionChain tc, Transition t) {
-		trans2chainBundle.put(t, tc);
-		
-		StateGraphNode node = fsmHelpers.getNode(t.getTo());
-		
-		// the chain ends if a state is reached
-		if (node instanceof State)
-			return;
-		
-		// the chain ends if source and destination coincide
-		if (tc.getTransition() instanceof NonInitialTransition && node==fsmHelpers.getNode(((NonInitialTransition)tc.getTransition()).getFrom()))
-			return;
-		
-		for (Transition next : getOutgoingTransitions(node)) {
-			// from the second transition in the chain on we have:
-			if (next instanceof TriggeredTransition) {
-				TriggeredTransition orig = (TriggeredTransition)copy2orig.get(next);
-				StateGraph origContainer = (StateGraph) orig.eContainer();
-				int idx = origContainer.getTransitions().indexOf(orig);
-				validationError("Segments following the triggering transition can have no triggers!\n", origContainer, FSMPackage.eINSTANCE.getStateGraph_Transitions(), idx);
-			}
-			
-			collectChainTransitions(tc, next);
-		}
-	}
-
-	private void findTransitionChains(StateGraph sg, Class<?> cls) {
-		findTransitionChains(sg, cls, true);
-	}
-	
-	private void findTransitionChains(StateGraph sg, Class<?> cls, boolean includeInitial) {
-		for (Transition t : sg.getTransitions()) {
-			if (cls.isInstance(t) || (includeInitial && (t instanceof InitialTransition))) {
-				addTransitionChain(t);
-			}
-		}
-		
-		// recurse into sub graphs of states
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				findTransitionChains(s.getSubgraph(), cls, includeInitial);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public void prepare(IDiagnostician validator) {
-		if (prepared)
-			return;
-		
-		prepared = true;
-		
-		this.validator = validator;
-		
-		ifitem2localId = new HashMap<AbstractInterfaceItem, Integer>();
-		ownObjects = new HashSet<StateGraphItem>();
-		targetsOfRefinedTransitions = new HashSet<Transition>();
-        baseTransitionHasDetailCode = new HashSet<Transition>();
-		node2data = new HashMap<StateGraphNode, NodeData>();
-		state2triggers = new HashMap<State, LinkedList<ActiveTrigger>>();
-		triggerstring2mif = new HashMap<String, MessageFromIf>();
-		trans2chainBundle = new TransitionToChainBundleMap();
-		copy2orig = new HashMap<EObject, EObject>();
-		orig2copy = new HashMap<EObject, EObject>();
-		
-		buildStateGraph();
-		computeInterfaceItemLocalIds(getModelComponent(), 0);
-		findOutgoingTransitions(getStateMachine());
-
-		doChecks(getStateMachine());
-		if (validator.isFailed())
-			return;
-		
-		if (getModelComponent().getCommType()==ComponentCommunicationType.DATA_DRIVEN) {
-			findTransitionChains(getStateMachine(), GuardedTransition.class);
-		}
-		else if (getModelComponent().getCommType()==ComponentCommunicationType.ASYNCHRONOUS) {
-			findLeafStateTriggers(getStateMachine());
-			fillTriggerStringMap();
-			findTransitionChains(getStateMachine(), TriggeredTransition.class);
-			computeCommonChainData();
-			findTransitionChains(getStateMachine(), GuardedTransition.class, false);
-			checkTransitionChains(getStateMachine());
-		}
-		else {
-			// event driven state machine
-			findLeafStateTriggers(getStateMachine());
-			fillTriggerStringMap();
-			findTransitionChains(getStateMachine(), TriggeredTransition.class);
-			computeCommonChainData();
-			checkTransitionChains(getStateMachine());
-		}
-	}
-
-	/**
-	 * 
-	 */
-	private void computeCommonChainData() {
-		for (TransitionChainBundle tcb : trans2chainBundle.values()) {
-			tcb.commonData = computeCommonChainData(tcb.chains);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public void release() {
-		if (!prepared)
-			return;
-		
-		prepared = false;
-		
-		// release resources
-		ifitem2localId = null;
-		ownObjects = null;
-		node2data = null;
-		state2triggers = null;
-		triggerstring2mif = null;
-		trans2chainBundle = null;
-		copy2orig = null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public void addOwnObject(StateGraphItem obj) {
-		ownObjects.add(obj);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public boolean isOwnObject(StateGraphItem obj) {
-		return ownObjects.contains(obj);
-	}
-	
-	/**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated NOT
-     */
-    public boolean hasBaseTransitionDetailCode(Transition trans) {
-        return baseTransitionHasDetailCode.contains(trans);
-    }
-
-    private int computeInterfaceItemLocalIds(ModelComponent mc, int offset) {
-		if (mc.getBase()!=null) {
-			// first recurse into base class
-			offset = computeInterfaceItemLocalIds(mc.getBase(), offset);
-		}
-		
-		EList<AbstractInterfaceItem> items = getOwnInterfaceItems(mc);
-		for (AbstractInterfaceItem item : items) {
-			ifitem2localId.put(item, offset);
-			++offset;
-		}
-		
-		return offset;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public int getInterfaceItemLocalId(AbstractInterfaceItem ifitem) {
-		Integer localId = ifitem2localId.get(ifitem);
-		if (localId!=null)
-			return localId.intValue();
-		else
-			return -1;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return 
-	 * @generated NOT
-	 */
-	public EObject computeCommonChainData(EList<TransitionChain> chains) {
-		return null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public boolean hasStateMachine() {
-		ModelComponent mc = getModelComponent();
-		while (mc!=null) {
-			if (mc.getStateMachine()!=null)
-				return true;
-			mc = mc.getBase();
-		}
-		return false;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getTriggerCodeName(MessageFromIf mif) {
-		return "TRIG_"+mif.getFrom().getName()+"__"+fsmNameProvider.getMessageName(mif.getMessage());
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getTriggerCodeName(ActiveTrigger at) {
-		String[] parts = at.getTrigger().split(TRIGGER_SEP);
-		return "TRIG_"+parts[0]+"__"+parts[1];
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<Transition> getOutgoingTransitions(StateGraphNode node) {
-		NodeData data = node2data.get(node);
-		if (data==null)
-			return new BasicEList<Transition>();
-		else
-			return new BasicEList<Transition>(data.getOutTrans());
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<Transition> getIncomingTransitions(StateGraphNode node) {
-		NodeData data = node2data.get(node);
-		if (data==null)
-			return new BasicEList<Transition>();
-		else
-			return new BasicEList<Transition>(data.getInTrans());
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<ActiveTrigger> getActiveTriggers(State state) {
-		LinkedList<ActiveTrigger> triggers = state2triggers.get(state);
-		if (triggers==null)
-			return new BasicEList<ActiveTrigger>();
-		else
-			return new BasicEList<ActiveTrigger>(triggers);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<MessageFromIf> getTriggers() {
-		return new BasicEList<MessageFromIf>(triggerstring2mif.values());
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<MessageFromIf> getOwnTriggers() {
-		BasicEList<MessageFromIf> result = new BasicEList<MessageFromIf>();
-		
-		EList<AbstractInterfaceItem> ownIfItems = getOwnInterfaceItems(getModelComponent());
-		
-		for(MessageFromIf mif : triggerstring2mif.values()) {
-			if (ownIfItems.contains(mif.getFrom()))
-				result.add(mif);
-		}
-		
-		Collections.sort(result, new Comparator<MessageFromIf>() {
-
-			@Override
-			public int compare(MessageFromIf o1, MessageFromIf o2) {
-				return getTriggerCodeName(o1).compareTo(getTriggerCodeName(o2));
-			}
-
-			
-		});
-		
-		return result;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getMessageID(MessageFromIf mif) {
-		// to be implemented by derived class
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public TransitionChain getChain(Transition trans) {
-		if (trans==null)
-			return null;
-		
-		TransitionChainBundle tcb = trans2chainBundle.get(trans);
-		if (tcb==null || tcb.chains.isEmpty())
-			return null;
-		
-		return tcb.chains.get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<TransitionChain> getChains(Transition trans) {
-		TransitionChainBundle tcb = trans2chainBundle.get(trans);
-		if(tcb == null)
-			new BasicEList<TransitionChain>();
-		
-		return tcb.chains;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EObject getData(Transition trans) {
-		if (trans==null)
-			return null;
-		
-		TransitionChainBundle tcb = trans2chainBundle.get(trans);
-		if (tcb==null || tcb.chains.isEmpty())
-			return null;
-		
-		if (tcb.chains.size()==1)
-			return tcb.chains.get(0).getData();
-		
-		return tcb.commonData;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<EObject> getIncomingMessages(AbstractInterfaceItem ifitem) {
-		return ifitem.getAllIncomingAbstractMessages();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public TransitionChain addTransitionChain(Transition t) {
-		TransitionChain tc = FsmGenFactory.eINSTANCE.createTransitionChain();
-		tc.setTransition(t);
-		
-		collectChainTransitions(tc, t);
-		
-		getTransitionChains().add(tc);
-		
-		return tc;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList<TransitionChain> getTransitionChains() {
-		if (transitionChains == null) {
-			transitionChains = new EObjectContainmentEList<TransitionChain>(TransitionChain.class, this, FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS);
-		}
-		return transitionChains;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<TransitionChain> getOwnTransitionChains() {
-		BasicEList<TransitionChain> result = new BasicEList<TransitionChain>();
-		
-		for (TransitionChain tc : getTransitionChains()) {
-			if (!targetsOfRefinedTransitions.contains(tc.getTransition()) && isOwnObject(tc.getTransition()))
-				result.add(tc);
-		}
-		
-		Collections.sort(result, new Comparator<TransitionChain>() {
-
-			@Override
-			public int compare(TransitionChain o1, TransitionChain o2) {
-				return fsmNameProvider.getFullPath(o1.getTransition()).compareTo(fsmNameProvider.getFullPath(o2.getTransition()));
-			}
-			
-		});
-		
-		return result;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<AbstractInterfaceItem> getOwnInterfaceItems(ModelComponent mc) {
-		return mc.getAbstractInterfaceItems();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList<AbstractInterfaceItem> getAllInterfaceItems() {
-		return getModelComponent().getAllAbstractInterfaceItems();
-	}
-
-	/*
-	 * In case of an abstract class we can have a transition to an EntryPoint
-	 * which is not connected inside its state.
-	 * For the TransitionChain handling during generation we need to replace
-	 * this terminal with a state terminal as if it where it a transition
-	 * to history.
-	 */
-	private StateGraphNode getAdjustedTargetNode(Transition t) {
-		StateGraphNode node = fsmHelpers.getNode(t.getTo());
-		if (node instanceof EntryPoint) {
-			if (getModelComponent(node).isAbstract()) {
-				NodeData data = node2data.get(node);
-				if (data==null || data.getOutTrans().isEmpty()) {
-					if (node.eContainer().eContainer() instanceof State) {
-						// in this case 
-						State newTarget = (State) node.eContainer().eContainer();
-						
-						StateTerminal st = FSMFactory.eINSTANCE.createStateTerminal();
-						st.setState(newTarget);
-						t.setTo(st);
-						
-						node = newTarget;
-					}
-				}
-			}
-		}
-		return node;
-	}
-	
-	private ModelComponent getModelComponent(EObject node) {
-		node = copy2orig.get(node);
-		while (node!=null) {
-			if (node instanceof ModelComponent)
-				return (ModelComponent) node;
-			node = node.eContainer();
-		}
-		return null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public boolean isMatching(Trigger trig, String trigstr) {
-		for (MessageFromIf mifp2 : trig.getMsgFromIfPairs()) {
-			String tr2 = getTriggerString(mifp2);
-			if (tr2.equals(trigstr))
-				return true;
-		}
-		return false;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public ContinuationTransition getDefaultBranch(EList<Transition> out) {
-		return getDefaultBranch((List<Transition>)out);
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EObject getOrig(EObject copy) {
-		return copy2orig.get(copy);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EObject getCopy(EObject orig) {
-		return orig2copy.get(orig);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getModelComponentName() {
-		return getModelComponent().getComponentName();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE:
-				return basicSetStateMachine(null, msgs);
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS:
-				return ((InternalEList<?>)getTransitionChains()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	private ContinuationTransition getDefaultBranch(List<Transition> out) {
-		for (Transition t : out) {
-			if (t instanceof ContinuationTransition)
-				return (ContinuationTransition) t;
-		}
-		return null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT:
-				if (resolve) return getModelComponent();
-				return basicGetModelComponent();
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE:
-				return getStateMachine();
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS:
-				return getTransitionChains();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("unchecked")
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT:
-				setModelComponent((ModelComponent)newValue);
-				return;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE:
-				setStateMachine((StateGraph)newValue);
-				return;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS:
-				getTransitionChains().clear();
-				getTransitionChains().addAll((Collection<? extends TransitionChain>)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT:
-				setModelComponent((ModelComponent)null);
-				return;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE:
-				setStateMachine((StateGraph)null);
-				return;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS:
-				getTransitionChains().clear();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT:
-				return modelComponent != null;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE:
-				return stateMachine != null;
-			case FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS:
-				return transitionChains != null && !transitionChains.isEmpty();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ExpandedModelComponentImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedRefinedStateImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedRefinedStateImpl.java
deleted file mode 100644
index 81822600d..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/ExpandedRefinedStateImpl.java
+++ /dev/null
@@ -1,392 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.etrice.core.fsm.fSM.DetailCode;
-import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
-import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.RefinedState;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateTerminal;
-import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.impl.SimpleStateImpl;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Expanded Refined State</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl#getInheritedEntry <em>Inherited Entry</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl#getInheritedExit <em>Inherited Exit</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedRefinedStateImpl#getInheritedDo <em>Inherited Do</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ExpandedRefinedStateImpl extends SimpleStateImpl implements ExpandedRefinedState {
-	
-	private FSMHelpers fsmHelpers = new FSMHelpers();
-	
-	/**
-	 * The cached value of the '{@link #getInheritedEntry() <em>Inherited Entry</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInheritedEntry()
-	 * @generated
-	 * @ordered
-	 */
-	protected DetailCode inheritedEntry;
-
-	/**
-	 * The cached value of the '{@link #getInheritedExit() <em>Inherited Exit</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInheritedExit()
-	 * @generated
-	 * @ordered
-	 */
-	protected DetailCode inheritedExit;
-
-	/**
-	 * The cached value of the '{@link #getInheritedDo() <em>Inherited Do</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInheritedDo()
-	 * @generated
-	 * @ordered
-	 */
-	protected DetailCode inheritedDo;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExpandedRefinedStateImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return FsmGenPackage.Literals.EXPANDED_REFINED_STATE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DetailCode getInheritedEntry() {
-		return inheritedEntry;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetInheritedEntry(DetailCode newInheritedEntry, NotificationChain msgs) {
-		DetailCode oldInheritedEntry = inheritedEntry;
-		inheritedEntry = newInheritedEntry;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY, oldInheritedEntry, newInheritedEntry);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInheritedEntry(DetailCode newInheritedEntry) {
-		if (newInheritedEntry != inheritedEntry) {
-			NotificationChain msgs = null;
-			if (inheritedEntry != null)
-				msgs = ((InternalEObject)inheritedEntry).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY, null, msgs);
-			if (newInheritedEntry != null)
-				msgs = ((InternalEObject)newInheritedEntry).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY, null, msgs);
-			msgs = basicSetInheritedEntry(newInheritedEntry, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY, newInheritedEntry, newInheritedEntry));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DetailCode getInheritedExit() {
-		return inheritedExit;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetInheritedExit(DetailCode newInheritedExit, NotificationChain msgs) {
-		DetailCode oldInheritedExit = inheritedExit;
-		inheritedExit = newInheritedExit;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT, oldInheritedExit, newInheritedExit);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInheritedExit(DetailCode newInheritedExit) {
-		if (newInheritedExit != inheritedExit) {
-			NotificationChain msgs = null;
-			if (inheritedExit != null)
-				msgs = ((InternalEObject)inheritedExit).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT, null, msgs);
-			if (newInheritedExit != null)
-				msgs = ((InternalEObject)newInheritedExit).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT, null, msgs);
-			msgs = basicSetInheritedExit(newInheritedExit, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT, newInheritedExit, newInheritedExit));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DetailCode getInheritedDo() {
-		return inheritedDo;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetInheritedDo(DetailCode newInheritedDo, NotificationChain msgs) {
-		DetailCode oldInheritedDo = inheritedDo;
-		inheritedDo = newInheritedDo;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO, oldInheritedDo, newInheritedDo);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInheritedDo(DetailCode newInheritedDo) {
-		if (newInheritedDo != inheritedDo) {
-			NotificationChain msgs = null;
-			if (inheritedDo != null)
-				msgs = ((InternalEObject)inheritedDo).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO, null, msgs);
-			if (newInheritedDo != null)
-				msgs = ((InternalEObject)newInheritedDo).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO, null, msgs);
-			msgs = basicSetInheritedDo(newInheritedDo, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO, newInheritedDo, newInheritedDo));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public void init(RefinedState rs) {
-		setName(rs.getName());
-		
-		// the next assignments take over the code and docu and state graph objects from rs
-		// but this is a copy and thus does no harm
-		setEntryCode(rs.getEntryCode());
-		setExitCode(rs.getExitCode());
-		setDoCode(rs.getDoCode());
-		setDocu(rs.getDocu());
-		setSubgraph(rs.getSubgraph());
-		
-		// now we collect the inherited detail code
-		setInheritedEntry(fsmHelpers.getInheritedEntryCode(rs));
-		setInheritedExit(fsmHelpers.getInheritedExitCode(rs));
-		setInheritedDo(fsmHelpers.getInheritedDoCode(rs));
-		
-		// remove refined state from its container
-		((StateGraph)rs.eContainer()).getStates().remove(rs);
-		
-		// put new state in place of SimpleState which is the ultimate target of the refined state
-		State bs = fsmHelpers.getBaseState(rs);
-		StateGraph parent = (StateGraph) bs.eContainer();
-		parent.getStates().add(this);
-		parent.getStates().remove(bs);
-		for (Transition trans : parent.getTransitions()) {
-			if (trans.getTo() instanceof StateTerminal) {
-				if (((StateTerminal)trans.getTo()).getState()==bs)
-					((StateTerminal)trans.getTo()).setState(this);
-			}
-			else if (trans.getTo() instanceof SubStateTrPointTerminal) {
-				if (((SubStateTrPointTerminal)trans.getTo()).getState()==bs)
-					((SubStateTrPointTerminal)trans.getTo()).setState(this);
-			}
-			if (trans instanceof NonInitialTransition) {
-				if (((NonInitialTransition)trans).getFrom() instanceof StateTerminal) {
-					if (((StateTerminal)((NonInitialTransition)trans).getFrom()).getState()==bs)
-						((StateTerminal)((NonInitialTransition)trans).getFrom()).setState(this);
-				}
-				else if (((NonInitialTransition)trans).getFrom() instanceof SubStateTrPointTerminal) {
-					if (((SubStateTrPointTerminal)((NonInitialTransition)trans).getFrom()).getState()==bs)
-						((SubStateTrPointTerminal)((NonInitialTransition)trans).getFrom()).setState(this);
-				}
-			}
-		}
-		
-		// move contents of base state to this state
-		StateGraph fromSG = bs.getSubgraph();
-		if (fromSG!=null) {
-			StateGraph toSG = getSubgraph();
-			if (toSG==null) {
-				toSG = FSMFactory.eINSTANCE.createStateGraph();
-				setSubgraph(toSG);
-			}
-			toSG.getChPoints().addAll(fromSG.getChPoints());
-			toSG.getStates().addAll(fromSG.getStates());
-			toSG.getTrPoints().addAll(fromSG.getTrPoints());
-			toSG.getTransitions().addAll(fromSG.getTransitions());
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY:
-				return basicSetInheritedEntry(null, msgs);
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT:
-				return basicSetInheritedExit(null, msgs);
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO:
-				return basicSetInheritedDo(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY:
-				return getInheritedEntry();
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT:
-				return getInheritedExit();
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO:
-				return getInheritedDo();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY:
-				setInheritedEntry((DetailCode)newValue);
-				return;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT:
-				setInheritedExit((DetailCode)newValue);
-				return;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO:
-				setInheritedDo((DetailCode)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY:
-				setInheritedEntry((DetailCode)null);
-				return;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT:
-				setInheritedExit((DetailCode)null);
-				return;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO:
-				setInheritedDo((DetailCode)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_ENTRY:
-				return inheritedEntry != null;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_EXIT:
-				return inheritedExit != null;
-			case FsmGenPackage.EXPANDED_REFINED_STATE__INHERITED_DO:
-				return inheritedDo != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ExpandedRefinedStateImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java
deleted file mode 100644
index aea4fb0bd..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/FsmGenPackageImpl.java
+++ /dev/null
@@ -1,509 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class FsmGenPackageImpl extends EPackageImpl implements FsmGenPackage {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass activeTriggerEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass expandedModelComponentEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass expandedRefinedStateEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iDiagnosticianEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iTransitionChainVisitorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass transitionChainEClass = null;
-
-	/**
-	 * Creates an instance of the model <b>Package</b>, registered with
-	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-	 * package URI value.
-	 * <p>Note: the correct way to create the package is via the static
-	 * factory method {@link #init init()}, which also performs
-	 * initialization of the package, or returns the registered package,
-	 * if one already exists.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.emf.ecore.EPackage.Registry
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage#eNS_URI
-	 * @see #init()
-	 * @generated
-	 */
-	private FsmGenPackageImpl() {
-		super(eNS_URI, FsmGenFactory.eINSTANCE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static boolean isInited = false;
-
-	/**
-	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
-	 * 
-	 * <p>This method is used to initialize {@link FsmGenPackage#eINSTANCE} when that field is accessed.
-	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #eNS_URI
-	 * @see #createPackageContents()
-	 * @see #initializePackageContents()
-	 * @generated
-	 */
-	public static FsmGenPackage init() {
-		if (isInited) return (FsmGenPackage)EPackage.Registry.INSTANCE.getEPackage(FsmGenPackage.eNS_URI);
-
-		// Obtain or create and register package
-		FsmGenPackageImpl theFsmGenPackage = (FsmGenPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof FsmGenPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new FsmGenPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		FSMPackage.eINSTANCE.eClass();
-
-		// Create package meta-data objects
-		theFsmGenPackage.createPackageContents();
-
-		// Initialize created meta-data
-		theFsmGenPackage.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theFsmGenPackage.freeze();
-
-  
-		// Update the registry and return the package
-		EPackage.Registry.INSTANCE.put(FsmGenPackage.eNS_URI, theFsmGenPackage);
-		return theFsmGenPackage;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getActiveTrigger() {
-		return activeTriggerEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getActiveTrigger_Msg() {
-		return (EReference)activeTriggerEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getActiveTrigger_Ifitem() {
-		return (EReference)activeTriggerEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getActiveTrigger_Trigger() {
-		return (EAttribute)activeTriggerEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getActiveTrigger_Transitions() {
-		return (EReference)activeTriggerEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getExpandedModelComponent() {
-		return expandedModelComponentEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedModelComponent_ModelComponent() {
-		return (EReference)expandedModelComponentEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedModelComponent_StateMachine() {
-		return (EReference)expandedModelComponentEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedModelComponent_TransitionChains() {
-		return (EReference)expandedModelComponentEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getExpandedRefinedState() {
-		return expandedRefinedStateEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedRefinedState_InheritedEntry() {
-		return (EReference)expandedRefinedStateEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedRefinedState_InheritedExit() {
-		return (EReference)expandedRefinedStateEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getExpandedRefinedState_InheritedDo() {
-		return (EReference)expandedRefinedStateEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIDiagnostician() {
-		return iDiagnosticianEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getITransitionChainVisitor() {
-		return iTransitionChainVisitorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getTransitionChain() {
-		return transitionChainEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getTransitionChain_Transition() {
-		return (EReference)transitionChainEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getTransitionChain_Data() {
-		return (EReference)transitionChainEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FsmGenFactory getFsmGenFactory() {
-		return (FsmGenFactory)getEFactoryInstance();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isCreated = false;
-
-	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void createPackageContents() {
-		if (isCreated) return;
-		isCreated = true;
-
-		// Create classes and their features
-		activeTriggerEClass = createEClass(ACTIVE_TRIGGER);
-		createEReference(activeTriggerEClass, ACTIVE_TRIGGER__MSG);
-		createEReference(activeTriggerEClass, ACTIVE_TRIGGER__IFITEM);
-		createEAttribute(activeTriggerEClass, ACTIVE_TRIGGER__TRIGGER);
-		createEReference(activeTriggerEClass, ACTIVE_TRIGGER__TRANSITIONS);
-
-		expandedModelComponentEClass = createEClass(EXPANDED_MODEL_COMPONENT);
-		createEReference(expandedModelComponentEClass, EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT);
-		createEReference(expandedModelComponentEClass, EXPANDED_MODEL_COMPONENT__STATE_MACHINE);
-		createEReference(expandedModelComponentEClass, EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS);
-
-		expandedRefinedStateEClass = createEClass(EXPANDED_REFINED_STATE);
-		createEReference(expandedRefinedStateEClass, EXPANDED_REFINED_STATE__INHERITED_ENTRY);
-		createEReference(expandedRefinedStateEClass, EXPANDED_REFINED_STATE__INHERITED_EXIT);
-		createEReference(expandedRefinedStateEClass, EXPANDED_REFINED_STATE__INHERITED_DO);
-
-		iDiagnosticianEClass = createEClass(IDIAGNOSTICIAN);
-
-		iTransitionChainVisitorEClass = createEClass(ITRANSITION_CHAIN_VISITOR);
-
-		transitionChainEClass = createEClass(TRANSITION_CHAIN);
-		createEReference(transitionChainEClass, TRANSITION_CHAIN__TRANSITION);
-		createEReference(transitionChainEClass, TRANSITION_CHAIN__DATA);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isInitialized = false;
-
-	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void initializePackageContents() {
-		if (isInitialized) return;
-		isInitialized = true;
-
-		// Initialize package
-		setName(eNAME);
-		setNsPrefix(eNS_PREFIX);
-		setNsURI(eNS_URI);
-
-		// Obtain other dependent packages
-		FSMPackage theFSMPackage = (FSMPackage)EPackage.Registry.INSTANCE.getEPackage(FSMPackage.eNS_URI);
-
-		// Create type parameters
-
-		// Set bounds for type parameters
-
-		// Add supertypes to classes
-		expandedRefinedStateEClass.getESuperTypes().add(theFSMPackage.getSimpleState());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(activeTriggerEClass, ActiveTrigger.class, "ActiveTrigger", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getActiveTrigger_Msg(), ecorePackage.getEObject(), null, "msg", null, 0, 1, ActiveTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getActiveTrigger_Ifitem(), theFSMPackage.getAbstractInterfaceItem(), null, "ifitem", null, 0, 1, ActiveTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getActiveTrigger_Trigger(), ecorePackage.getEString(), "trigger", null, 0, 1, ActiveTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getActiveTrigger_Transitions(), theFSMPackage.getTriggeredTransition(), null, "transitions", null, 0, -1, ActiveTrigger.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(expandedModelComponentEClass, ExpandedModelComponent.class, "ExpandedModelComponent", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getExpandedModelComponent_ModelComponent(), theFSMPackage.getModelComponent(), null, "modelComponent", null, 0, 1, ExpandedModelComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getExpandedModelComponent_StateMachine(), theFSMPackage.getStateGraph(), null, "stateMachine", null, 0, 1, ExpandedModelComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getExpandedModelComponent_TransitionChains(), this.getTransitionChain(), null, "transitionChains", null, 0, -1, ExpandedModelComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		EOperation op = addEOperation(expandedModelComponentEClass, null, "prepare", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, this.getIDiagnostician(), "validator", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, null, "release", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, null, "addOwnObject", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getStateGraphItem(), "obj", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEBoolean(), "isOwnObject", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getStateGraphItem(), "obj", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEBoolean(), "hasBaseTransitionDetailCode", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, ecorePackage.getEBoolean(), "hasStateMachine", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEString(), "getTriggerCodeName", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getMessageFromIf(), "mif", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEString(), "getTriggerCodeName", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, this.getActiveTrigger(), "at", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, theFSMPackage.getTransition(), "getOutgoingTransitions", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getStateGraphNode(), "node", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, theFSMPackage.getTransition(), "getIncomingTransitions", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getStateGraphNode(), "node", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, this.getActiveTrigger(), "getActiveTriggers", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getState(), "state", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, theFSMPackage.getMessageFromIf(), "getTriggers", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, theFSMPackage.getMessageFromIf(), "getOwnTriggers", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEString(), "getMessageID", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getMessageFromIf(), "mif", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, this.getTransitionChain(), "getChain", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, this.getTransitionChain(), "getChains", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, this.getTransitionChain(), "getOwnTransitionChains", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, theFSMPackage.getAbstractInterfaceItem(), "getOwnInterfaceItems", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getModelComponent(), "mc", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, theFSMPackage.getAbstractInterfaceItem(), "getAllInterfaceItems", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEBoolean(), "isMatching", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTrigger(), "trig", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, ecorePackage.getEString(), "trigstr", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, theFSMPackage.getContinuationTransition(), "getDefaultBranch", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "out", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEObject(), "getOrig", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, ecorePackage.getEObject(), "copy", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEObject(), "getCopy", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, ecorePackage.getEObject(), "orig", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(expandedModelComponentEClass, ecorePackage.getEString(), "getModelComponentName", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEObject(), "getData", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEObject(), "getIncomingMessages", 0, -1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getAbstractInterfaceItem(), "ifitem", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, this.getTransitionChain(), "addTransitionChain", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEInt(), "getInterfaceItemLocalId", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getAbstractInterfaceItem(), "ifitem", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(expandedModelComponentEClass, ecorePackage.getEObject(), "computeCommonChainData", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, this.getTransitionChain(), "chains", 0, -1, IS_UNIQUE, IS_ORDERED);
-
-		initEClass(expandedRefinedStateEClass, ExpandedRefinedState.class, "ExpandedRefinedState", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getExpandedRefinedState_InheritedEntry(), theFSMPackage.getDetailCode(), null, "inheritedEntry", null, 0, 1, ExpandedRefinedState.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getExpandedRefinedState_InheritedExit(), theFSMPackage.getDetailCode(), null, "inheritedExit", null, 0, 1, ExpandedRefinedState.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getExpandedRefinedState_InheritedDo(), theFSMPackage.getDetailCode(), null, "inheritedDo", null, 0, 1, ExpandedRefinedState.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		op = addEOperation(expandedRefinedStateEClass, null, "init", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getRefinedState(), "rs", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		initEClass(iDiagnosticianEClass, Object.class, "IDiagnostician", IS_ABSTRACT, IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(iTransitionChainVisitorEClass, Object.class, "ITransitionChainVisitor", IS_ABSTRACT, IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(transitionChainEClass, TransitionChain.class, "TransitionChain", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getTransitionChain_Transition(), theFSMPackage.getTransition(), null, "transition", null, 0, 1, TransitionChain.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getTransitionChain_Data(), ecorePackage.getEObject(), null, "data", null, 0, 1, TransitionChain.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(transitionChainEClass, theFSMPackage.getState(), "getStateContext", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		addEOperation(transitionChainEClass, ecorePackage.getEBoolean(), "isHandler", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		op = addEOperation(transitionChainEClass, ecorePackage.getEString(), "genExecuteChain", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, this.getITransitionChainVisitor(), "tcv", 0, 1, IS_UNIQUE, IS_ORDERED);
-
-		// Create resource
-		createResource(eNS_URI);
-	}
-
-} //FsmGenPackageImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/TransitionChainImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/TransitionChainImpl.java
deleted file mode 100644
index b54eb5b3a..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/impl/TransitionChainImpl.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ITransitionChainVisitor;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
-import org.eclipse.etrice.core.fsm.fSM.ExitPoint;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TransitionChainStartTransition;
-import org.eclipse.etrice.core.fsm.fSM.TransitionPoint;
-import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Transition Chain</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl#getTransition <em>Transition</em>}</li>
- *   <li>{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.TransitionChainImpl#getData <em>Data</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class TransitionChainImpl extends MinimalEObjectImpl.Container implements TransitionChain {
-	
-	private FSMHelpers fsmHelpers = new FSMHelpers();
-	private FSMNameProvider fsmNameProvider = new FSMNameProvider();
-	
-	/**
-	 * The cached value of the '{@link #getTransition() <em>Transition</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTransition()
-	 * @generated
-	 * @ordered
-	 */
-	protected Transition transition;
-
-	/**
-	 * The cached value of the '{@link #getData() <em>Data</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getData()
-	 * @generated
-	 * @ordered
-	 */
-	protected EObject data;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected TransitionChainImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return FsmGenPackage.Literals.TRANSITION_CHAIN;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Transition getTransition() {
-		if (transition != null && transition.eIsProxy()) {
-			InternalEObject oldTransition = (InternalEObject)transition;
-			transition = (Transition)eResolveProxy(oldTransition);
-			if (transition != oldTransition) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.TRANSITION_CHAIN__TRANSITION, oldTransition, transition));
-			}
-		}
-		return transition;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Transition basicGetTransition() {
-		return transition;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTransition(Transition newTransition) {
-		Transition oldTransition = transition;
-		transition = newTransition;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.TRANSITION_CHAIN__TRANSITION, oldTransition, transition));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject getData() {
-		if (data != null && data.eIsProxy()) {
-			InternalEObject oldData = (InternalEObject)data;
-			data = eResolveProxy(oldData);
-			if (data != oldData) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FsmGenPackage.TRANSITION_CHAIN__DATA, oldData, data));
-			}
-		}
-		return data;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject basicGetData() {
-		return data;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setData(EObject newData) {
-		EObject oldData = data;
-		data = newData;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FsmGenPackage.TRANSITION_CHAIN__DATA, oldData, data));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public State getStateContext() {
-		if (getTransition().eContainer().eContainer() instanceof State)
-			return (State) getTransition().eContainer().eContainer();
-
-		return null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public boolean isHandler() {
-		if (getTransition() instanceof TransitionChainStartTransition) {
-			TransitionChainStartTransition trans = (TransitionChainStartTransition)getTransition();
-			if (trans.getFrom() instanceof TrPointTerminal) {
-				TrPoint tp = ((TrPointTerminal)trans.getFrom()).getTrPoint();
-				if (tp instanceof TransitionPoint)
-					return ((TransitionPoint)tp).isHandler();
-			}
-			else if (trans.getFrom() instanceof SubStateTrPointTerminal) {
-				TrPoint tp = ((SubStateTrPointTerminal)trans.getFrom()).getTrPoint();
-				if (tp instanceof TransitionPoint)
-					assert(false): "not allowed to connect TransitionPoint to exterior";
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String genExecuteChain(ITransitionChainVisitor tcv) {
-		ExpandedModelComponent emc = getExpandedModelComponent();
-		
-		StringBuilder result = new StringBuilder();
-		
-		/* TODO: the next generated code declares a correctly typed variable for the generic data.
-		 * It is hard to determine whether it is actually needed though.
-		 * It is needed in non-initial transitions with action code that are not data driven.
-		 * It might be needed in condition expressions. But this code would have to be parsed
-		 * with uncertain result (because of e.g. comments).
-		 */
-		result.append(tcv.genTypedData(this));
-		
-		genChainCode(getTransition(), emc, tcv, result);
-		return result.toString();
-	}
-	
-	private void genChainCode(Transition tr,
-			ExpandedModelComponent emc, ITransitionChainVisitor tcv, StringBuilder result) {
-		
-		result.append(tcv.genActionOperationCall(tr));
-		
-		StateGraphNode node = fsmHelpers.getNode(tr.getTo());
-		EList<Transition> out = emc.getOutgoingTransitions(node);
-		if (node instanceof ChoicePoint) {
-			ContinuationTransition dflt = emc.getDefaultBranch(out);
-			assert(dflt!=null): "ChoicePoint "+fsmNameProvider.getFullPath(node)+" has no default branch!";
-			
-			// generate if/else
-			boolean isFirst = true;
-			for (Transition cond : out) {
-				if (cond==dflt)
-					continue;
-				
-				assert(cond instanceof CPBranchTransition): "The non default ChoicePoint branch "
-					+fsmNameProvider.getFullPath(cond)+" must be of type CPBranchTransition!";
-				
-				result.append(tcv.genElseIfBranch((CPBranchTransition)cond, isFirst));
-				isFirst = false;
-
-				genChainCode(cond, emc, tcv, result);
-			}
-			
-			// generate default
-			result.append(tcv.genElseBranch(dflt));
-			
-			genChainCode(dflt, emc, tcv, result);
-			
-			result.append(tcv.genEndIf());
-		}
-		else {
-			if (node instanceof TrPoint) {
-				if (node instanceof TransitionPoint) {
-					// TransitionPoint is final destination of the chain
-					result.append(tcv.genReturnState(getStateContext(), false));
-					return;
-				}
-				else {
-					assert(out.size()<=1): "TrPoint "+fsmNameProvider.getFullPath(node)
-					+" is expected to have at most one outgoing transition!";
-					if (out.size()==1) {
-						State state = (node.eContainer().eContainer() instanceof State)? (State)node.eContainer().eContainer():null;
-						if (node instanceof EntryPoint) {
-							if (state!=null && emc.isOwnObject(state) && state.getEntryCode()!=null && !state.getEntryCode().getLines().isEmpty())
-								result.append(tcv.genEntryOperationCall(state));
-						}
-						else if (node instanceof ExitPoint) {
-							if (state!=null && emc.isOwnObject(state) && state.getExitCode()!=null && !state.getExitCode().getLines().isEmpty())
-								result.append(tcv.genExitOperationCall(state));
-						}
-						else {
-							assert(false): "unexpected sub type";
-						}
-					}
-				}
-				genChainCode(out.get(0), emc, tcv, result);
-			}
-			else {
-				// the following assertion should always hold true
-				assert(node instanceof State): "A transition target can be a ChoicePoint, a TrPoint or a State!";
-				
-				result.append(tcv.genReturnState((State) node, true));
-			}
-		}
-	}
-
-	private ExpandedModelComponent getExpandedModelComponent() {
-		EObject obj = getTransition();
-		while (obj!=null) {
-			obj = obj.eContainer();
-			if (obj instanceof ExpandedModelComponent)
-				return (ExpandedModelComponent) obj;
-		}
-		return null;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FsmGenPackage.TRANSITION_CHAIN__TRANSITION:
-				if (resolve) return getTransition();
-				return basicGetTransition();
-			case FsmGenPackage.TRANSITION_CHAIN__DATA:
-				if (resolve) return getData();
-				return basicGetData();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FsmGenPackage.TRANSITION_CHAIN__TRANSITION:
-				setTransition((Transition)newValue);
-				return;
-			case FsmGenPackage.TRANSITION_CHAIN__DATA:
-				setData((EObject)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.TRANSITION_CHAIN__TRANSITION:
-				setTransition((Transition)null);
-				return;
-			case FsmGenPackage.TRANSITION_CHAIN__DATA:
-				setData((EObject)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FsmGenPackage.TRANSITION_CHAIN__TRANSITION:
-				return transition != null;
-			case FsmGenPackage.TRANSITION_CHAIN__DATA:
-				return data != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //TransitionChainImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceFactoryImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceFactoryImpl.java
deleted file mode 100644
index dc9adb5d3..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceFactoryImpl.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.util;
-
-import org.eclipse.emf.common.util.URI;
-
-import org.eclipse.emf.ecore.resource.Resource;
-
-import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource Factory</b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.util.FsmGenResourceImpl
- * @generated
- */
-public class FsmGenResourceFactoryImpl extends ResourceFactoryImpl {
-	/**
-	 * Creates an instance of the resource factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FsmGenResourceFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Resource createResource(URI uri) {
-		Resource result = new FsmGenResourceImpl(uri);
-		return result;
-	}
-
-} //FsmGenResourceFactoryImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceImpl.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceImpl.java
deleted file mode 100644
index 3e7cb3bc7..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenResourceImpl.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- *  Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License v1.0
- *  which accompanies this distribution, and is available at
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  CONTRIBUTORS:
- *  		Henrik Rentz-Reichert (initial contribution)
- *  
- */
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.util;
-
-import org.eclipse.emf.common.util.URI;
-
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource </b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.util.FsmGenResourceFactoryImpl
- * @generated
- */
-public class FsmGenResourceImpl extends XMIResourceImpl {
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param uri the URI of the new resource.
-	 * @generated
-	 */
-	public FsmGenResourceImpl(URI uri) {
-		super(uri);
-	}
-
-} //FsmGenResourceImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenUtil.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenUtil.java
deleted file mode 100644
index dae41c9c2..000000000
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/util/FsmGenUtil.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2013 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen.util;
-
-import org.eclipse.etrice.core.fsm.fSM.Trigger;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenFactory;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class FsmGenUtil {
-	
-	private FSMHelpers fsmHelpers = new FSMHelpers();
-
-	/**
-	 * @param trig the trigger
-	 * @param trigstr the encoded trigger string
-	 * @return <code>true</code> if the encoded trigger string is matching the {@link Trigger}
-	 * 
-	 * @see org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#isMatching(Trigger, String)
-	 */
-	public boolean isMatching(Trigger trig, String trigstr) {
-		return FsmGenFactory.eINSTANCE.createExpandedModelComponent().isMatching(trig, trigstr);
-	}
-	
-	/**
-	 * @param at an {@link ActiveTrigger}
-	 * @return <code>true</code> if the active trigger has defined a guard
-	 */
-	public boolean hasGuard(ActiveTrigger at) {
-		for (TriggeredTransition t : at.getTransitions()) {
-			for (Trigger trig : t.getTriggers()) {
-				if (isMatching(trig, at.getTrigger())
-						&& fsmHelpers.hasGuard(trig))
-					return true;
-			}
-		}
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.ecore b/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.ecore
index 938a6d308..1bdeb278b 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.ecore
+++ b/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.ecore
@@ -215,11 +215,13 @@
   <eClassifiers xsi:type="ecore:EClass" name="WiredSubSystemClass" eSuperTypes="#//WiredStructureClass">
     <eStructuralFeatures xsi:type="ecore:EReference" name="subSystemClass" eType="ecore:EClass ../../org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore#//SubSystemClass"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExpandedActorClass" eSuperTypes="../../org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore#//ExpandedModelComponent">
-    <eOperations name="getVarDeclData" eType="ecore:EClass ../../org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore#//VarDecl">
-      <eParameters name="trans" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//Transition"/>
+  <eClassifiers xsi:type="ecore:EClass" name="ExpandedActorClass">
+    <eOperations name="getInterfaceItemLocalId" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt">
+      <eParameters name="ifitem" eType="ecore:EClass ../../org.eclipse.etrice.core.fsm/model/generated/FSM.ecore#//AbstractInterfaceItem"/>
     </eOperations>
     <eStructuralFeatures xsi:type="ecore:EReference" name="actorClass" eType="ecore:EClass ../../org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore#//ActorClass"
         changeable="false" volatile="true" transient="true" derived="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="graphContainer" eType="ecore:EClass ../../org.eclipse.etrice.core.genmodel.fsm/model/fsmgen.ecore#//GraphContainer"
+        containment="true"/>
   </eClassifiers>
 </ecore:EPackage>
diff --git a/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.genmodel b/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.genmodel
index 15bdb9bdd..040cb0426 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.genmodel
+++ b/plugins/org.eclipse.etrice.core.genmodel/model/etricegen.genmodel
@@ -165,12 +165,6 @@
     </genClasses>
     <genClasses ecoreClass="etricegen.ecore#//ExpandedActorClass">
       <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference etricegen.ecore#//ExpandedActorClass/actorClass"/>
-      <genOperations ecoreOperation="etricegen.ecore#//ExpandedActorClass/getData">
-        <genParameters ecoreParameter="etricegen.ecore#//ExpandedActorClass/getData/trans"/>
-      </genOperations>
-    </genClasses>
-    <genClasses ecoreClass="etricegen.ecore#//TransitionChain">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference etricegen.ecore#//TransitionChain/data"/>
     </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/plugins/org.eclipse.etrice.core.genmodel/plugin.properties b/plugins/org.eclipse.etrice.core.genmodel/plugin.properties
index acbbabf20..07a56b2fa 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/plugin.properties
+++ b/plugins/org.eclipse.etrice.core.genmodel/plugin.properties
@@ -5,4 +5,4 @@
 # $Id$
 
 pluginName = eTriceGen Model
-providerName = eTrice
+providerName = Eclipse eTrice
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/RoomGenmodelValidator.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/RoomGenmodelValidator.java
index 142917c15..e8492bc73 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/RoomGenmodelValidator.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/RoomGenmodelValidator.java
@@ -24,8 +24,8 @@ import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.etrice.core.common.validation.ICustomValidator;
 import org.eclipse.etrice.core.genmodel.builder.GeneratorModelBuilder;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullLogger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger;
 import org.eclipse.etrice.core.room.RoomModel;
 import org.eclipse.etrice.core.room.RoomPackage;
 import org.eclipse.xtext.validation.CheckMode;
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/BindingUtil.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/BindingUtil.java
index 6d3330305..bbf1d9050 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/BindingUtil.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/BindingUtil.java
@@ -26,7 +26,7 @@ import org.eclipse.etrice.core.genmodel.etricegen.PortInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.PortKind;
 import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.ActorContainerRef;
 import org.eclipse.etrice.core.room.ActorRef;
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/GeneratorModelBuilder.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/GeneratorModelBuilder.java
index 19c1002d7..aa84d3e58 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/GeneratorModelBuilder.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/builder/GeneratorModelBuilder.java
@@ -26,6 +26,7 @@ import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.etrice.core.RoomStandaloneSetup;
 import org.eclipse.etrice.core.genmodel.etricegen.AbstractInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInterfaceInstance;
@@ -47,8 +48,10 @@ import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.SystemInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.impl.AbstractInstanceImpl;
 import org.eclipse.etrice.core.genmodel.etricegen.impl.StructureInstanceImpl;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.ActorContainerClass;
 import org.eclipse.etrice.core.room.ActorContainerRef;
@@ -74,6 +77,8 @@ import org.eclipse.etrice.core.room.SubSystemClass;
 import org.eclipse.etrice.core.room.SubSystemRef;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 
+import com.google.inject.Injector;
+
 /**
  * A class for the creation of an intermediate model combining all information needed by
  * the code generator.
@@ -1256,9 +1261,13 @@ public class GeneratorModelBuilder {
 					+" of "+((RoomModel)ac.eContainer()).getName());
 
 		ExpandedActorClass xpac = ETriceGenFactory.eINSTANCE.createExpandedActorClass();
-		xpac.setModelComponent(ac);
-		
-		xpac.prepare(diagnostician);
+		Injector injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration();
+		ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(injector, diagnostician);
+		GraphContainer gc = builder.createTransformedModel(ac);
+		builder.withChainHeads(gc);
+		builder.withCommonData(gc);
+		builder.withTriggersInStates(gc);
+		xpac.setGraphContainer(gc);
 		
 		return xpac;
 	}
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ETriceGenPackage.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ETriceGenPackage.java
index b43db7179..b1d782965 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ETriceGenPackage.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ETriceGenPackage.java
@@ -16,7 +16,6 @@ import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EEnum;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
 
 /**
  * <!-- begin-user-doc -->
@@ -2061,40 +2060,22 @@ public interface ETriceGenPackage extends EPackage {
 	int WIRED_SUB_SYSTEM_CLASS_FEATURE_COUNT = WIRED_STRUCTURE_CLASS_FEATURE_COUNT + 1;
 
 	/**
-	 * The feature id for the '<em><b>Model Component</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_ACTOR_CLASS__MODEL_COMPONENT = FsmGenPackage.EXPANDED_MODEL_COMPONENT__MODEL_COMPONENT;
-
-	/**
-	 * The feature id for the '<em><b>State Machine</b></em>' containment reference.
+	 * The feature id for the '<em><b>Actor Class</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 * @ordered
 	 */
-	int EXPANDED_ACTOR_CLASS__STATE_MACHINE = FsmGenPackage.EXPANDED_MODEL_COMPONENT__STATE_MACHINE;
+	int EXPANDED_ACTOR_CLASS__ACTOR_CLASS = 0;
 
 	/**
-	 * The feature id for the '<em><b>Transition Chains</b></em>' containment reference list.
+	 * The feature id for the '<em><b>Graph Container</b></em>' containment reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 * @ordered
 	 */
-	int EXPANDED_ACTOR_CLASS__TRANSITION_CHAINS = FsmGenPackage.EXPANDED_MODEL_COMPONENT__TRANSITION_CHAINS;
-
-	/**
-	 * The feature id for the '<em><b>Actor Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXPANDED_ACTOR_CLASS__ACTOR_CLASS = FsmGenPackage.EXPANDED_MODEL_COMPONENT_FEATURE_COUNT + 0;
+	int EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER = 1;
 
 	/**
 	 * The number of structural features of the '<em>Expanded Actor Class</em>' class.
@@ -2103,7 +2084,7 @@ public interface ETriceGenPackage extends EPackage {
 	 * @generated
 	 * @ordered
 	 */
-	int EXPANDED_ACTOR_CLASS_FEATURE_COUNT = FsmGenPackage.EXPANDED_MODEL_COMPONENT_FEATURE_COUNT + 1;
+	int EXPANDED_ACTOR_CLASS_FEATURE_COUNT = 2;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.etrice.core.genmodel.etricegen.PortKind <em>Port Kind</em>}' enum.
@@ -2936,6 +2917,17 @@ public interface ETriceGenPackage extends EPackage {
 	EReference getExpandedActorClass_ActorClass();
 
 	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getGraphContainer <em>Graph Container</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Graph Container</em>'.
+	 * @see org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getGraphContainer()
+	 * @see #getExpandedActorClass()
+	 * @generated
+	 */
+	EReference getExpandedActorClass_GraphContainer();
+
+	/**
 	 * Returns the meta object for class '{@link org.eclipse.etrice.core.genmodel.etricegen.WiredStructureClass <em>Wired Structure Class</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -3813,6 +3805,14 @@ public interface ETriceGenPackage extends EPackage {
 		EReference EXPANDED_ACTOR_CLASS__ACTOR_CLASS = eINSTANCE.getExpandedActorClass_ActorClass();
 
 		/**
+		 * The meta object literal for the '<em><b>Graph Container</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER = eINSTANCE.getExpandedActorClass_GraphContainer();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.etrice.core.genmodel.etricegen.impl.WiredStructureClassImpl <em>Wired Structure Class</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ExpandedActorClass.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ExpandedActorClass.java
index 980dfc04c..92082868d 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ExpandedActorClass.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/ExpandedActorClass.java
@@ -12,10 +12,10 @@
 
 package org.eclipse.etrice.core.genmodel.etricegen;
 
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
 import org.eclipse.etrice.core.room.ActorClass;
-import org.eclipse.etrice.core.room.VarDecl;
 
 /**
  * <!-- begin-user-doc -->
@@ -29,13 +29,14 @@ import org.eclipse.etrice.core.room.VarDecl;
  * </p>
  * <ul>
  *   <li>{@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getActorClass <em>Actor Class</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getGraphContainer <em>Graph Container</em>}</li>
  * </ul>
  *
  * @see org.eclipse.etrice.core.genmodel.etricegen.ETriceGenPackage#getExpandedActorClass()
  * @model
  * @generated
  */
-public interface ExpandedActorClass extends ExpandedModelComponent {
+public interface ExpandedActorClass extends EObject {
 	/**
 	 * Returns the value of the '<em><b>Actor Class</b></em>' reference.
 	 * <!-- begin-user-doc -->
@@ -51,11 +52,37 @@ public interface ExpandedActorClass extends ExpandedModelComponent {
 	ActorClass getActorClass();
 
 	/**
+	 * Returns the value of the '<em><b>Graph Container</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Graph Container</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Graph Container</em>' containment reference.
+	 * @see #setGraphContainer(GraphContainer)
+	 * @see org.eclipse.etrice.core.genmodel.etricegen.ETriceGenPackage#getExpandedActorClass_GraphContainer()
+	 * @model containment="true"
+	 * @generated
+	 */
+	GraphContainer getGraphContainer();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass#getGraphContainer <em>Graph Container</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Graph Container</em>' containment reference.
+	 * @see #getGraphContainer()
+	 * @generated
+	 */
+	void setGraphContainer(GraphContainer value);
+
+	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @model
 	 * @generated
 	 */
-	VarDecl getVarDeclData(Transition trans);
+	int getInterfaceItemLocalId(AbstractInterfaceItem ifitem);
 
 } // ExpandedActorClass
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ETriceGenPackageImpl.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ETriceGenPackageImpl.java
index ff18bb954..a9497b38b 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ETriceGenPackageImpl.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ETriceGenPackageImpl.java
@@ -978,6 +978,15 @@ public class ETriceGenPackageImpl extends EPackageImpl implements ETriceGenPacka
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public EReference getExpandedActorClass_GraphContainer() {
+		return (EReference)expandedActorClassEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public EClass getWiredStructureClass() {
 		return wiredStructureClassEClass;
 	}
@@ -1298,6 +1307,7 @@ public class ETriceGenPackageImpl extends EPackageImpl implements ETriceGenPacka
 
 		expandedActorClassEClass = createEClass(EXPANDED_ACTOR_CLASS);
 		createEReference(expandedActorClassEClass, EXPANDED_ACTOR_CLASS__ACTOR_CLASS);
+		createEReference(expandedActorClassEClass, EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER);
 
 		// Create enums
 		portKindEEnum = createEEnum(PORT_KIND);
@@ -1350,7 +1360,6 @@ public class ETriceGenPackageImpl extends EPackageImpl implements ETriceGenPacka
 		serviceImplInstanceEClass.getESuperTypes().add(this.getInterfaceItemInstance());
 		wiredActorClassEClass.getESuperTypes().add(this.getWiredStructureClass());
 		wiredSubSystemClassEClass.getESuperTypes().add(this.getWiredStructureClass());
-		expandedActorClassEClass.getESuperTypes().add(theFsmGenPackage.getExpandedModelComponent());
 
 		// Initialize classes and features; add operations and parameters
 		initEClass(rootEClass, Root.class, "Root", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
@@ -1512,9 +1521,10 @@ public class ETriceGenPackageImpl extends EPackageImpl implements ETriceGenPacka
 
 		initEClass(expandedActorClassEClass, ExpandedActorClass.class, "ExpandedActorClass", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEReference(getExpandedActorClass_ActorClass(), theRoomPackage.getActorClass(), null, "actorClass", null, 0, 1, ExpandedActorClass.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
+		initEReference(getExpandedActorClass_GraphContainer(), theFsmGenPackage.getGraphContainer(), null, "graphContainer", null, 0, 1, ExpandedActorClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-		op = addEOperation(expandedActorClassEClass, theRoomPackage.getVarDecl(), "getVarDeclData", 0, 1, IS_UNIQUE, IS_ORDERED);
-		addEParameter(op, theFSMPackage.getTransition(), "trans", 0, 1, IS_UNIQUE, IS_ORDERED);
+		op = addEOperation(expandedActorClassEClass, ecorePackage.getEInt(), "getInterfaceItemLocalId", 0, 1, IS_UNIQUE, IS_ORDERED);
+		addEParameter(op, theFSMPackage.getAbstractInterfaceItem(), "ifitem", 0, 1, IS_UNIQUE, IS_ORDERED);
 
 		// Initialize enums and add enum literals
 		initEEnum(portKindEEnum, PortKind.class, "PortKind");
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ExpandedActorClassImpl.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ExpandedActorClassImpl.java
index dd5a909b0..838a0eb99 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ExpandedActorClassImpl.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/impl/ExpandedActorClassImpl.java
@@ -11,33 +11,21 @@
  */
 package org.eclipse.etrice.core.genmodel.etricegen.impl;
 
-import java.util.ArrayList;
+import java.util.HashMap;
 
-import org.eclipse.emf.common.util.BasicEList;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.Trigger;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.genmodel.etricegen.ETriceGenPackage;
 import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
 import org.eclipse.etrice.core.room.ActorClass;
-import org.eclipse.etrice.core.room.InterfaceItem;
-import org.eclipse.etrice.core.room.Message;
-import org.eclipse.etrice.core.room.Port;
-import org.eclipse.etrice.core.room.RefableType;
-import org.eclipse.etrice.core.room.RoomFactory;
-import org.eclipse.etrice.core.room.SAP;
-import org.eclipse.etrice.core.room.SPP;
-import org.eclipse.etrice.core.room.VarDecl;
-import org.eclipse.etrice.core.room.util.RoomHelpers;
 
 /**
  * <!-- begin-user-doc -->
@@ -48,15 +36,24 @@ import org.eclipse.etrice.core.room.util.RoomHelpers;
  * </p>
  * <ul>
  *   <li>{@link org.eclipse.etrice.core.genmodel.etricegen.impl.ExpandedActorClassImpl#getActorClass <em>Actor Class</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.genmodel.etricegen.impl.ExpandedActorClassImpl#getGraphContainer <em>Graph Container</em>}</li>
  * </ul>
  *
  * @generated
  */
-public class ExpandedActorClassImpl extends ExpandedModelComponentImpl implements ExpandedActorClass {
-	
-	private RoomHelpers roomHelpers = new RoomHelpers();
+public class ExpandedActorClassImpl extends EObjectImpl implements ExpandedActorClass {
 	
 	/**
+	 * The cached value of the '{@link #getGraphContainer() <em>Graph Container</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGraphContainer()
+	 * @generated
+	 * @ordered
+	 */
+	protected GraphContainer graphContainer;
+
+	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -91,16 +88,16 @@ public class ExpandedActorClassImpl extends ExpandedModelComponentImpl implement
 	 * @generated NOT
 	 */
 	public ActorClass basicGetActorClass() {
-		return (ActorClass) getModelComponent();
+		return (ActorClass) getGraphContainer().getComponent();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @generated NOT
+	 * @generated
 	 */
-	public VarDecl getVarDeclData(Transition trans) {
-		return (VarDecl) getData(trans);
+	public GraphContainer getGraphContainer() {
+		return graphContainer;
 	}
 
 	/**
@@ -108,14 +105,37 @@ public class ExpandedActorClassImpl extends ExpandedModelComponentImpl implement
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__ACTOR_CLASS:
-				if (resolve) return getActorClass();
-				return basicGetActorClass();
+	public NotificationChain basicSetGraphContainer(GraphContainer newGraphContainer, NotificationChain msgs) {
+		GraphContainer oldGraphContainer = graphContainer;
+		graphContainer = newGraphContainer;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER, oldGraphContainer, newGraphContainer);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
-		return super.eGet(featureID, resolve, coreType);
+		return msgs;
+	}
+
+	/**
+	 * we maintain a map of local IDs for interface items
+	 */
+	private HashMap<AbstractInterfaceItem, Integer> ifitem2localId;
+	
+	/**
+	 * the recursive computation of the local IDs of interface items
+	 */
+    private int computeInterfaceItemLocalIds(ModelComponent mc, int offset) {
+		if (mc.getBase()!=null) {
+			// first recurse into base class
+			offset = computeInterfaceItemLocalIds(mc.getBase(), offset);
+		}
+		
+		EList<AbstractInterfaceItem> items = mc.getAbstractInterfaceItems();
+		for (AbstractInterfaceItem item : items) {
+			ifitem2localId.put(item, offset);
+			++offset;
+		}
+		
+		return offset;
 	}
 
 	/**
@@ -123,128 +143,113 @@ public class ExpandedActorClassImpl extends ExpandedModelComponentImpl implement
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__ACTOR_CLASS:
-				return basicGetActorClass() != null;
+	public void setGraphContainer(GraphContainer newGraphContainer) {
+		if (newGraphContainer != graphContainer) {
+			NotificationChain msgs = null;
+			if (graphContainer != null)
+				msgs = ((InternalEObject)graphContainer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER, null, msgs);
+			if (newGraphContainer != null)
+				msgs = ((InternalEObject)newGraphContainer).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER, null, msgs);
+			msgs = basicSetGraphContainer(newGraphContainer, msgs);
+			if (msgs != null) msgs.dispatch();
 		}
-		return super.eIsSet(featureID);
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER, newGraphContainer, newGraphContainer));
 	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#addTransitionChain(org.eclipse.etrice.core.fsm.fSM.Transition)
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated NOT
 	 */
-	@Override
-	public TransitionChain addTransitionChain(Transition t) {
-		TransitionChain tc = super.addTransitionChain(t);
-		
-		if (t instanceof TriggeredTransition) {
-			VarDecl data = null;
-			
-			// TODO: after introduction of VarDecl after 'action' leave this to validation
-			
-			boolean first = true;
-			for (Trigger tr : ((TriggeredTransition)t).getTriggers()) {
-				for (MessageFromIf mif : tr.getMsgFromIfPairs()) {
-					VarDecl msgData = ((Message)mif.getMessage()).getData();
-					if (first) {
-						first = false;
-						data = msgData;
-					}
-					else {
-						if (data!=null) {
-							if (msgData==null) {
-								validationError("If one MessageFromIf has data all have to have data for a given transition!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-							}
-							else {
-								VarDecl a = msgData;
-								if (data.getRefType().getType()!=a.getRefType().getType())
-									validationError("The data types of all MessageFromIf have to be the same!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-								if (data.getRefType().isRef() !=a.getRefType().isRef())
-									validationError("The data types of all MessageFromIf have to be the same ref type!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-							}
-						}
-						else {
-							if (msgData!=null)
-								validationError("If one MessageFromIf has no data all have to have no data for a given transition!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-						}
-					}
-				}
-			}
-	
-			if (first)
-				validationError("Triggered transition has to have a message from interface!", t, FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
-			
-			tc.setData(data);
+	public int getInterfaceItemLocalId(AbstractInterfaceItem ifitem) {
+		if (ifitem2localId==null) {
+			ifitem2localId = new HashMap<AbstractInterfaceItem, Integer>();
+			computeInterfaceItemLocalIds(getActorClass(), 0);
 		}
 		
-		return tc;
+		Integer localId = ifitem2localId.get(ifitem);
+		if (localId!=null)
+			return localId.intValue();
+		else
+			return -1;
 	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getIncomingMessages(org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem)
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
 	 */
 	@Override
-	public EList<EObject> getIncomingMessages(AbstractInterfaceItem ifitem) {
-		return new BasicEList<EObject>(roomHelpers.getMessageListDeep((InterfaceItem) ifitem, false));
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER:
+				return basicSetGraphContainer(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getMessageID(org.eclipse.etrice.core.fsm.fSM.MessageFromIf)
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
 	 */
 	@Override
-	public String getMessageID(MessageFromIf mif) {
-		if (mif.getFrom() instanceof Port) {
-			Port p = (Port) mif.getFrom();
-			return p.getProtocol().getName()+(p.isConjugated()?".OUT_":".IN_")+fsmNameProvider.getMessageName(mif.getMessage());
-		}
-		else if (mif.getFrom() instanceof SAP) {
-			SAP sap = (SAP) mif.getFrom();
-			return sap.getProtocol().getName()+".OUT_"+fsmNameProvider.getMessageName(mif.getMessage());
-		}
-		else if (mif.getFrom() instanceof SPP) {
-			SPP spp = (SPP) mif.getFrom();
-			return spp.getProtocol().getName()+".IN_"+fsmNameProvider.getMessageName(mif.getMessage());
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__ACTOR_CLASS:
+				if (resolve) return getActorClass();
+				return basicGetActorClass();
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER:
+				return getGraphContainer();
 		}
+		return super.eGet(featureID, resolve, coreType);
+	}
 
-		return "unknown interface item";
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER:
+				setGraphContainer((GraphContainer)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
 	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#computeCommonChainData(org.eclipse.emf.common.util.EList)
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
 	 */
 	@Override
-	public EObject computeCommonChainData(EList<TransitionChain> chains) {
-		if (chains.size()==1)
-			return chains.get(0).getData();
-		else {
-			ArrayList<RefableType> types = new ArrayList<RefableType>();
-			for (TransitionChain chain : chains) {
-				if (chain.getData()!=null)
-					types.add(((VarDecl) chain.getData()).getRefType());
-				else
-					types.add(null);
-			}
-			RefableType rt = roomHelpers.getLastCommonSuperType(types);
-			if (rt!=null) {
-				VarDecl vd = RoomFactory.eINSTANCE.createVarDecl();
-				vd.setName("data");
-				vd.setRefType(rt);
-				return vd;
-			}
-			else {
-				return null;
-			}
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER:
+				setGraphContainer((GraphContainer)null);
+				return;
 		}
+		super.eUnset(featureID);
 	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.impl.ExpandedModelComponentImpl#getModelComponentName()
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
 	 */
 	@Override
-	public String getModelComponentName() {
-		return getActorClass().getName();
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__ACTOR_CLASS:
+				return basicGetActorClass() != null;
+			case ETriceGenPackage.EXPANDED_ACTOR_CLASS__GRAPH_CONTAINER:
+				return graphContainer != null;
+		}
+		return super.eIsSet(featureID);
 	}
 	
 } //ExpandedActorClassImpl
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenAdapterFactory.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenAdapterFactory.java
index de1b193b4..ff4eebb8b 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenAdapterFactory.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenAdapterFactory.java
@@ -16,8 +16,30 @@ import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.genmodel.etricegen.*;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
+import org.eclipse.etrice.core.genmodel.etricegen.AbstractInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInterfaceInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.BindingInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ConnectionInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ETriceGenPackage;
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.OpenBinding;
+import org.eclipse.etrice.core.genmodel.etricegen.OpenServiceConnection;
+import org.eclipse.etrice.core.genmodel.etricegen.OptionalActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.PortInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.etricegen.SAPInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SPPInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ServiceImplInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SystemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Wire;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredStructureClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredSubSystemClass;
 
 /**
  * <!-- begin-user-doc -->
@@ -168,10 +190,6 @@ public class ETriceGenAdapterFactory extends AdapterFactoryImpl {
 				return createExpandedActorClassAdapter();
 			}
 			@Override
-			public Adapter caseExpandedModelComponent(ExpandedModelComponent object) {
-				return createExpandedModelComponentAdapter();
-			}
-			@Override
 			public Adapter defaultCase(EObject object) {
 				return createEObjectAdapter();
 			}
@@ -416,20 +434,6 @@ public class ETriceGenAdapterFactory extends AdapterFactoryImpl {
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent <em>Expanded Model Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-	 * @generated
-	 */
-	public Adapter createExpandedModelComponentAdapter() {
-		return null;
-	}
-
-	/**
 	 * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass <em>Expanded Actor Class</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenSwitch.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenSwitch.java
index b9de6a85f..1a3fdfdbf 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenSwitch.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/etricegen/util/ETriceGenSwitch.java
@@ -15,8 +15,30 @@ package org.eclipse.etrice.core.genmodel.etricegen.util;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.util.Switch;
-import org.eclipse.etrice.core.genmodel.etricegen.*;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
+import org.eclipse.etrice.core.genmodel.etricegen.AbstractInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInterfaceInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.BindingInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ConnectionInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ETriceGenPackage;
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.OpenBinding;
+import org.eclipse.etrice.core.genmodel.etricegen.OpenServiceConnection;
+import org.eclipse.etrice.core.genmodel.etricegen.OptionalActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.PortInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.etricegen.SAPInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SPPInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ServiceImplInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SystemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Wire;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredStructureClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredSubSystemClass;
 
 /**
  * <!-- begin-user-doc -->
@@ -235,7 +257,6 @@ public class ETriceGenSwitch<T> extends Switch<T> {
 			case ETriceGenPackage.EXPANDED_ACTOR_CLASS: {
 				ExpandedActorClass expandedActorClass = (ExpandedActorClass)theEObject;
 				T result = caseExpandedActorClass(expandedActorClass);
-				if (result == null) result = caseExpandedModelComponent(expandedActorClass);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
@@ -499,21 +520,6 @@ public class ETriceGenSwitch<T> extends Switch<T> {
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Expanded Model Component</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Expanded Model Component</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseExpandedModelComponent(ExpandedModelComponent object) {
-		return null;
-	}
-
-	/**
 	 * Returns the result of interpreting the object as an instance of '<em>Wired Structure Class</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
diff --git a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/util/RoomCrossReferencer.java b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/util/RoomCrossReferencer.java
index 02a9751c6..97d6ec238 100644
--- a/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/util/RoomCrossReferencer.java
+++ b/plugins/org.eclipse.etrice.core.genmodel/src/org/eclipse/etrice/core/genmodel/util/RoomCrossReferencer.java
@@ -28,6 +28,7 @@ import org.eclipse.etrice.core.room.DataType;
 import org.eclipse.etrice.core.room.EnumerationType;
 import org.eclipse.etrice.core.room.InterfaceItem;
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.Operation;
 import org.eclipse.etrice.core.room.Port;
 import org.eclipse.etrice.core.room.PortClass;
@@ -162,6 +163,9 @@ public class RoomCrossReferencer {
 			do {
 				getAttributeDataClasses(dataClasses, enumClasses, cls.getAttributes());
 				getOperationDataClasses(dataClasses, enumClasses, cls.getOperations());
+				for(ProtocolClass protocol : getReferencedProtocolClasses(cls)) {
+					enumClasses.addAll(getReferencedEnumClasses(protocol));
+				}
 				cls = cls.getActorBase();
 			}
 			while (cls!=null);
@@ -288,11 +292,11 @@ public class RoomCrossReferencer {
 		for (ProtocolClass pc : protocolClasses) {
 			for (Message m : pc.getIncomingMessages()) {
 				if (m.getData()!=null)
-					getVarDeclDataClasses(dataClasses, enumClasses, Collections.singleton(m.getData()));
+					getMessageDataClasses(dataClasses, enumClasses, Collections.singleton(m.getData()));
 			}
 			for (Message m : pc.getOutgoingMessages()) {
 				if (m.getData()!=null)
-					getVarDeclDataClasses(dataClasses, enumClasses, Collections.singleton(m.getData()));
+					getMessageDataClasses(dataClasses, enumClasses, Collections.singleton(m.getData()));
 			}
 			
 			if (pc.getRegular()!=null) {
@@ -366,6 +370,12 @@ public class RoomCrossReferencer {
 		}
 	}
 
+	private void getMessageDataClasses(Set<DataClass> dataClasses, Set<EnumerationType> enumClasses, Collection<MessageData> decls) {
+		for (MessageData vd : decls) {
+			getClasses(vd.getRefType().getType(), dataClasses, enumClasses);
+		}
+	}
+
 	private void getAttributeDataClasses(Set<DataClass> dataClasses, Set<EnumerationType> enumClasses, Collection<Attribute> attributes) {
 		for (Attribute attr : attributes) {
 			getClasses(attr.getType().getType(), dataClasses, enumClasses);
diff --git a/plugins/org.eclipse.etrice.core.room.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.core.room.ui/META-INF/MANIFEST.MF
index 2263ca073..ce15bfda9 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.core.room.ui/META-INF/MANIFEST.MF
@@ -23,16 +23,19 @@ Require-Bundle: org.eclipse.etrice.core.fsm.ui;bundle-version="1.1.3",
  org.eclipse.core.filesystem;bundle-version="1.3.0",
  org.eclipse.help,
  com.google.inject,
- org.eclipse.etrice.expressions.ui
+ org.eclipse.etrice.expressions.ui,
+ org.eclipse.etrice.ui.behavior.fsm;bundle-version="1.1.3",
+ org.eclipse.etrice.dctools;bundle-version="1.1.3"
 Import-Package: org.apache.log4j
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.eclipse.etrice.core.ui,
  org.eclipse.etrice.core.ui.contentassist,
  org.eclipse.etrice.core.ui.contentassist.antlr,
+ org.eclipse.etrice.core.ui.contentassist.antlr.internal,
  org.eclipse.etrice.core.ui.editor,
  org.eclipse.etrice.core.ui.internal,
  org.eclipse.etrice.core.ui.linking,
  org.eclipse.etrice.core.ui.preferences,
  org.eclipse.etrice.core.ui.quickfix,
- org.eclipse.etrice.core.ui.contentassist.antlr.internal
+ org.eclipse.etrice.core.ui.util
 Bundle-Activator: org.eclipse.etrice.core.ui.RoomUiActivator
diff --git a/plugins/org.eclipse.etrice.core.room.ui/plugin.xml b/plugins/org.eclipse.etrice.core.room.ui/plugin.xml
index aad007144..311b0a822 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/plugin.xml
+++ b/plugins/org.eclipse.etrice.core.room.ui/plugin.xml
@@ -142,7 +142,71 @@
                 </reference>
             </activeWhen>
         </handler>
+    </extension>
+     
+    <extension
+         point="org.eclipse.ui.commands">
+      <command
+            description="Migrate model to transition data with generic name"
+            id="org.eclipse.etrice.core.room.ui.migratetransitiondata"
+            name="Migrate Transition Data Style">
+      </command>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?after=org.eclipse.etrice.core.Room.validate">
+			<command
+         commandId="org.eclipse.etrice.core.room.ui.migratetransitiondata"
+         icon="icons/correction_change.gif">
+				<visibleWhen checkEnabled="false">
+                	<reference definitionId="org.eclipse.etrice.core.Room.Editor.opened">
+                	</reference>
+            	</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+	    <handler
+            class="org.eclipse.etrice.core.ui.RoomExecutableExtensionFactory:org.eclipse.etrice.core.ui.handlers.MigrateTransitionData"
+            commandId="org.eclipse.etrice.core.room.ui.migratetransitiondata">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.etrice.core.Room.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
     </extension>   
+     
+    <extension
+         point="org.eclipse.ui.commands">
+      <command
+            description="Migrate model to smart action codes"
+            id="org.eclipse.etrice.core.room.ui.migrateactioncodes"
+            name="Migrate to Smart Action Codes">
+      </command>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?after=org.eclipse.etrice.core.fsm.FSM.validate">
+			<command
+         commandId="org.eclipse.etrice.core.room.ui.migrateactioncodes"
+         icon="icons/correction_change.gif">
+				<visibleWhen checkEnabled="false">
+                	<reference definitionId="org.eclipse.etrice.core.Room.Editor.opened">
+                	</reference>
+            	</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+	    <handler
+            class="org.eclipse.etrice.core.ui.RoomExecutableExtensionFactory:org.eclipse.etrice.core.ui.handlers.MigrateActionCodes"
+            commandId="org.eclipse.etrice.core.room.ui.migrateactioncodes">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.etrice.core.Room.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
+    </extension>
 
 <!-- adding resource factories -->
 
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/AbstractRoomProposalProvider.java b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/AbstractRoomProposalProvider.java
index 2bec217e6..dc1371252 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/AbstractRoomProposalProvider.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/AbstractRoomProposalProvider.java
@@ -58,6 +58,12 @@ public class AbstractRoomProposalProvider extends org.eclipse.etrice.core.fsm.ui
 	public void completeVarDecl_RefType(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
 		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
 	}
+	public void completeMessageData_DeprecatedName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeMessageData_RefType(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
 	public void completeRefableType_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
 		lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor);
 	}
@@ -558,6 +564,9 @@ public class AbstractRoomProposalProvider extends org.eclipse.etrice.core.fsm.ui
 	public void complete_VarDecl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
 		// subclasses may override
 	}
+	public void complete_MessageData(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
 	public void complete_RefableType(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
 		// subclasses may override
 	}
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/RoomParser.java b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/RoomParser.java
index 86e777865..944085c60 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/RoomParser.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/RoomParser.java
@@ -100,6 +100,8 @@ public class RoomParser extends AbstractContentAssistParser {
 					put(grammarAccess.getLiteralTypeAccess().getAlternatives(), "rule__LiteralType__Alternatives");
 					put(grammarAccess.getRoomModelAccess().getGroup(), "rule__RoomModel__Group__0");
 					put(grammarAccess.getVarDeclAccess().getGroup(), "rule__VarDecl__Group__0");
+					put(grammarAccess.getMessageDataAccess().getGroup(), "rule__MessageData__Group__0");
+					put(grammarAccess.getMessageDataAccess().getGroup_0(), "rule__MessageData__Group_0__0");
 					put(grammarAccess.getRefableTypeAccess().getGroup(), "rule__RefableType__Group__0");
 					put(grammarAccess.getPrimitiveTypeAccess().getGroup(), "rule__PrimitiveType__Group__0");
 					put(grammarAccess.getPrimitiveTypeAccess().getGroup_6(), "rule__PrimitiveType__Group_6__0");
@@ -141,6 +143,7 @@ public class RoomParser extends AbstractContentAssistParser {
 					put(grammarAccess.getCompoundProtocolClassAccess().getGroup(), "rule__CompoundProtocolClass__Group__0");
 					put(grammarAccess.getSubProtocolAccess().getGroup(), "rule__SubProtocol__Group__0");
 					put(grammarAccess.getMessageAccess().getGroup(), "rule__Message__Group__0");
+					put(grammarAccess.getMessageAccess().getGroup_3(), "rule__Message__Group_3__0");
 					put(grammarAccess.getPortClassAccess().getGroup(), "rule__PortClass__Group__0");
 					put(grammarAccess.getPortClassAccess().getGroup_2(), "rule__PortClass__Group_2__0");
 					put(grammarAccess.getInMessageHandlerAccess().getGroup(), "rule__InMessageHandler__Group__0");
@@ -273,6 +276,8 @@ public class RoomParser extends AbstractContentAssistParser {
 					put(grammarAccess.getRoomModelAccess().getAnnotationTypesAssignment_5_8(), "rule__RoomModel__AnnotationTypesAssignment_5_8");
 					put(grammarAccess.getVarDeclAccess().getNameAssignment_0(), "rule__VarDecl__NameAssignment_0");
 					put(grammarAccess.getVarDeclAccess().getRefTypeAssignment_2(), "rule__VarDecl__RefTypeAssignment_2");
+					put(grammarAccess.getMessageDataAccess().getDeprecatedNameAssignment_0_0(), "rule__MessageData__DeprecatedNameAssignment_0_0");
+					put(grammarAccess.getMessageDataAccess().getRefTypeAssignment_1(), "rule__MessageData__RefTypeAssignment_1");
 					put(grammarAccess.getRefableTypeAccess().getTypeAssignment_0(), "rule__RefableType__TypeAssignment_0");
 					put(grammarAccess.getRefableTypeAccess().getRefAssignment_1(), "rule__RefableType__RefAssignment_1");
 					put(grammarAccess.getPrimitiveTypeAccess().getNameAssignment_1(), "rule__PrimitiveType__NameAssignment_1");
@@ -344,9 +349,9 @@ public class RoomParser extends AbstractContentAssistParser {
 					put(grammarAccess.getSubProtocolAccess().getProtocolAssignment_3(), "rule__SubProtocol__ProtocolAssignment_3");
 					put(grammarAccess.getMessageAccess().getPrivAssignment_0(), "rule__Message__PrivAssignment_0");
 					put(grammarAccess.getMessageAccess().getNameAssignment_2(), "rule__Message__NameAssignment_2");
-					put(grammarAccess.getMessageAccess().getDataAssignment_4(), "rule__Message__DataAssignment_4");
-					put(grammarAccess.getMessageAccess().getAnnotationsAssignment_6(), "rule__Message__AnnotationsAssignment_6");
-					put(grammarAccess.getMessageAccess().getDocuAssignment_7(), "rule__Message__DocuAssignment_7");
+					put(grammarAccess.getMessageAccess().getDataAssignment_3_1(), "rule__Message__DataAssignment_3_1");
+					put(grammarAccess.getMessageAccess().getAnnotationsAssignment_4(), "rule__Message__AnnotationsAssignment_4");
+					put(grammarAccess.getMessageAccess().getDocuAssignment_5(), "rule__Message__DocuAssignment_5");
 					put(grammarAccess.getPortClassAccess().getUserCodeAssignment_2_1(), "rule__PortClass__UserCodeAssignment_2_1");
 					put(grammarAccess.getPortClassAccess().getMsgHandlersAssignment_3_0(), "rule__PortClass__MsgHandlersAssignment_3_0");
 					put(grammarAccess.getPortClassAccess().getOperationsAssignment_3_1(), "rule__PortClass__OperationsAssignment_3_1");
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoom.g b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoom.g
index 652b3391c..554580e05 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoom.g
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoom.g
@@ -170,6 +170,34 @@ finally {
 
 
 
+// Entry rule entryRuleMessageData
+entryRuleMessageData 
+:
+{ before(grammarAccess.getMessageDataRule()); }
+	 ruleMessageData
+{ after(grammarAccess.getMessageDataRule()); } 
+	 EOF 
+;
+
+// Rule MessageData
+ruleMessageData
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getMessageDataAccess().getGroup()); }
+(rule__MessageData__Group__0)
+{ after(grammarAccess.getMessageDataAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
 // Entry rule entryRuleRefableType
 entryRuleRefableType 
 :
@@ -1804,6 +1832,32 @@ finally {
 
 
 
+// Entry rule entryRuleTransitionBase
+entryRuleTransitionBase 
+:
+{ before(grammarAccess.getTransitionBaseRule()); }
+	 ruleTransitionBase
+{ after(grammarAccess.getTransitionBaseRule()); } 
+	 EOF 
+;
+
+// Rule TransitionBase
+ruleTransitionBase
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTransitionBaseAccess().getAlternatives()); }
+(rule__TransitionBase__Alternatives)
+{ after(grammarAccess.getTransitionBaseAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
 
 
 // Entry rule entryRuleTransition
@@ -3929,6 +3983,27 @@ finally {
 	restoreStackSize(stackSize);
 }
 
+rule__TransitionBase__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); }
+	ruleTransition
+{ after(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); }
+	ruleRefinedTransition
+{ after(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
 
 rule__Transition__Alternatives
     @init {
@@ -4917,6 +4992,130 @@ finally {
 
 
 
+rule__MessageData__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MessageData__Group__0__Impl
+	rule__MessageData__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MessageData__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getGroup_0()); }
+(rule__MessageData__Group_0__0)?
+{ after(grammarAccess.getMessageDataAccess().getGroup_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__MessageData__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MessageData__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MessageData__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getRefTypeAssignment_1()); }
+(rule__MessageData__RefTypeAssignment_1)
+{ after(grammarAccess.getMessageDataAccess().getRefTypeAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MessageData__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MessageData__Group_0__0__Impl
+	rule__MessageData__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MessageData__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getDeprecatedNameAssignment_0_0()); }
+(rule__MessageData__DeprecatedNameAssignment_0_0)
+{ after(grammarAccess.getMessageDataAccess().getDeprecatedNameAssignment_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__MessageData__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MessageData__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MessageData__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getColonKeyword_0_1()); }
+
+	':' 
+
+{ after(grammarAccess.getMessageDataAccess().getColonKeyword_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
 rule__RefableType__Group__0
     @init {
 		int stackSize = keepStackSize();
@@ -9847,11 +10046,9 @@ rule__Message__Group__3__Impl
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); }
-
-	'(' 
-
-{ after(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); }
+{ before(grammarAccess.getMessageAccess().getGroup_3()); }
+(rule__Message__Group_3__0)?
+{ after(grammarAccess.getMessageAccess().getGroup_3()); }
 )
 
 ;
@@ -9878,9 +10075,9 @@ rule__Message__Group__4__Impl
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getDataAssignment_4()); }
-(rule__Message__DataAssignment_4)?
-{ after(grammarAccess.getMessageAccess().getDataAssignment_4()); }
+{ before(grammarAccess.getMessageAccess().getAnnotationsAssignment_4()); }
+(rule__Message__AnnotationsAssignment_4)*
+{ after(grammarAccess.getMessageAccess().getAnnotationsAssignment_4()); }
 )
 
 ;
@@ -9895,7 +10092,6 @@ rule__Message__Group__5
     }
 :
 	rule__Message__Group__5__Impl
-	rule__Message__Group__6
 ;
 finally {
 	restoreStackSize(stackSize);
@@ -9907,11 +10103,9 @@ rule__Message__Group__5__Impl
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); }
-
-	')' 
-
-{ after(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); }
+{ before(grammarAccess.getMessageAccess().getDocuAssignment_5()); }
+(rule__Message__DocuAssignment_5)?
+{ after(grammarAccess.getMessageAccess().getDocuAssignment_5()); }
 )
 
 ;
@@ -9920,27 +10114,41 @@ finally {
 }
 
 
-rule__Message__Group__6
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Message__Group_3__0
     @init {
 		int stackSize = keepStackSize();
     }
 :
-	rule__Message__Group__6__Impl
-	rule__Message__Group__7
+	rule__Message__Group_3__0__Impl
+	rule__Message__Group_3__1
 ;
 finally {
 	restoreStackSize(stackSize);
 }
 
-rule__Message__Group__6__Impl
+rule__Message__Group_3__0__Impl
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getAnnotationsAssignment_6()); }
-(rule__Message__AnnotationsAssignment_6)*
-{ after(grammarAccess.getMessageAccess().getAnnotationsAssignment_6()); }
+{ before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0()); }
+
+	'(' 
+
+{ after(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0()); }
 )
 
 ;
@@ -9949,26 +10157,27 @@ finally {
 }
 
 
-rule__Message__Group__7
+rule__Message__Group_3__1
     @init {
 		int stackSize = keepStackSize();
     }
 :
-	rule__Message__Group__7__Impl
+	rule__Message__Group_3__1__Impl
+	rule__Message__Group_3__2
 ;
 finally {
 	restoreStackSize(stackSize);
 }
 
-rule__Message__Group__7__Impl
+rule__Message__Group_3__1__Impl
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getDocuAssignment_7()); }
-(rule__Message__DocuAssignment_7)?
-{ after(grammarAccess.getMessageAccess().getDocuAssignment_7()); }
+{ before(grammarAccess.getMessageAccess().getDataAssignment_3_1()); }
+(rule__Message__DataAssignment_3_1)?
+{ after(grammarAccess.getMessageAccess().getDataAssignment_3_1()); }
 )
 
 ;
@@ -9977,14 +10186,34 @@ finally {
 }
 
 
+rule__Message__Group_3__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Message__Group_3__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
 
+rule__Message__Group_3__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2()); }
 
+	')' 
 
+{ after(grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2()); }
+)
 
-
-
-
-
+;
+finally {
+	restoreStackSize(stackSize);
+}
 
 
 
@@ -23546,6 +23775,36 @@ finally {
 	restoreStackSize(stackSize);
 }
 
+rule__MessageData__DeprecatedNameAssignment_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); }
+	RULE_ID{ after(grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MessageData__RefTypeAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); }
+	ruleRefableType{ after(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
 rule__RefableType__TypeAssignment_0
     @init {
 		int stackSize = keepStackSize();
@@ -24660,14 +24919,14 @@ finally {
 	restoreStackSize(stackSize);
 }
 
-rule__Message__DataAssignment_4
+rule__Message__DataAssignment_3_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); }
-	ruleVarDecl{ after(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); }
+{ before(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); }
+	ruleMessageData{ after(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); }
 )
 
 ;
@@ -24675,14 +24934,14 @@ finally {
 	restoreStackSize(stackSize);
 }
 
-rule__Message__AnnotationsAssignment_6
+rule__Message__AnnotationsAssignment_4
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
-	ruleAnnotation{ after(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
+{ before(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
+	ruleAnnotation{ after(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
 )
 
 ;
@@ -24690,14 +24949,14 @@ finally {
 	restoreStackSize(stackSize);
 }
 
-rule__Message__DocuAssignment_7
+rule__Message__DocuAssignment_5
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
-{ before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); }
-	ruleDocumentation{ after(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); }
+{ before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); }
+	ruleDocumentation{ after(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); }
 )
 
 ;
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomLexer.java b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomLexer.java
index c2a3bba8f..b8ddfa949 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomLexer.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomLexer.java
@@ -2661,10 +2661,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_HEX;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27858:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
-            // InternalRoom.g:27858:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalRoom.g:28117:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalRoom.g:28117:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalRoom.g:27858:12: ( '0x' | '0X' )
+            // InternalRoom.g:28117:12: ( '0x' | '0X' )
             int alt1=2;
             int LA1_0 = input.LA(1);
 
@@ -2692,7 +2692,7 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt1) {
                 case 1 :
-                    // InternalRoom.g:27858:13: '0x'
+                    // InternalRoom.g:28117:13: '0x'
                     {
                     match("0x"); 
 
@@ -2700,7 +2700,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:27858:18: '0X'
+                    // InternalRoom.g:28117:18: '0X'
                     {
                     match("0X"); 
 
@@ -2710,7 +2710,7 @@ public class InternalRoomLexer extends Lexer {
 
             }
 
-            // InternalRoom.g:27858:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalRoom.g:28117:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             int cnt2=0;
             loop2:
             do {
@@ -2764,12 +2764,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_CC_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27860:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
-            // InternalRoom.g:27860:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+            // InternalRoom.g:28119:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalRoom.g:28119:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalRoom.g:27860:27: ( options {greedy=false; } : . )*
+            // InternalRoom.g:28119:27: ( options {greedy=false; } : . )*
             loop3:
             do {
                 int alt3=2;
@@ -2803,7 +2803,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt3) {
             	case 1 :
-            	    // InternalRoom.g:27860:55: .
+            	    // InternalRoom.g:28119:55: .
             	    {
             	    matchAny(); 
 
@@ -2833,10 +2833,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ID;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27862:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
-            // InternalRoom.g:27862:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalRoom.g:28121:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalRoom.g:28121:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalRoom.g:27862:11: ( '^' )?
+            // InternalRoom.g:28121:11: ( '^' )?
             int alt4=2;
             int LA4_0 = input.LA(1);
 
@@ -2845,7 +2845,7 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt4) {
                 case 1 :
-                    // InternalRoom.g:27862:11: '^'
+                    // InternalRoom.g:28121:11: '^'
                     {
                     match('^'); 
 
@@ -2863,7 +2863,7 @@ public class InternalRoomLexer extends Lexer {
                 recover(mse);
                 throw mse;}
 
-            // InternalRoom.g:27862:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalRoom.g:28121:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             loop5:
             do {
                 int alt5=2;
@@ -2912,10 +2912,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_INT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27864:10: ( ( '0' .. '9' )+ )
-            // InternalRoom.g:27864:12: ( '0' .. '9' )+
+            // InternalRoom.g:28123:10: ( ( '0' .. '9' )+ )
+            // InternalRoom.g:28123:12: ( '0' .. '9' )+
             {
-            // InternalRoom.g:27864:12: ( '0' .. '9' )+
+            // InternalRoom.g:28123:12: ( '0' .. '9' )+
             int cnt6=0;
             loop6:
             do {
@@ -2929,7 +2929,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt6) {
             	case 1 :
-            	    // InternalRoom.g:27864:13: '0' .. '9'
+            	    // InternalRoom.g:28123:13: '0' .. '9'
             	    {
             	    matchRange('0','9'); 
 
@@ -2961,10 +2961,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27866:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
-            // InternalRoom.g:27866:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:28125:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalRoom.g:28125:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalRoom.g:27866:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:28125:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -2982,10 +2982,10 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalRoom.g:27866:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+                    // InternalRoom.g:28125:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalRoom.g:27866:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalRoom.g:28125:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
                     loop7:
                     do {
                         int alt7=3;
@@ -3001,7 +3001,7 @@ public class InternalRoomLexer extends Lexer {
 
                         switch (alt7) {
                     	case 1 :
-                    	    // InternalRoom.g:27866:21: '\\\\' .
+                    	    // InternalRoom.g:28125:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3009,7 +3009,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:27866:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalRoom.g:28125:28: ~ ( ( '\\\\' | '\"' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -3034,10 +3034,10 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:27866:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
+                    // InternalRoom.g:28125:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalRoom.g:27866:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalRoom.g:28125:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
                     loop8:
                     do {
                         int alt8=3;
@@ -3053,7 +3053,7 @@ public class InternalRoomLexer extends Lexer {
 
                         switch (alt8) {
                     	case 1 :
-                    	    // InternalRoom.g:27866:54: '\\\\' .
+                    	    // InternalRoom.g:28125:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3061,7 +3061,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:27866:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalRoom.g:28125:61: ~ ( ( '\\\\' | '\\'' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -3104,12 +3104,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ML_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27868:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
-            // InternalRoom.g:27868:19: '/*' ( options {greedy=false; } : . )* '*/'
+            // InternalRoom.g:28127:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalRoom.g:28127:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalRoom.g:27868:24: ( options {greedy=false; } : . )*
+            // InternalRoom.g:28127:24: ( options {greedy=false; } : . )*
             loop10:
             do {
                 int alt10=2;
@@ -3134,7 +3134,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt10) {
             	case 1 :
-            	    // InternalRoom.g:27868:52: .
+            	    // InternalRoom.g:28127:52: .
             	    {
             	    matchAny(); 
 
@@ -3164,12 +3164,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_SL_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27870:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
-            // InternalRoom.g:27870:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            // InternalRoom.g:28129:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalRoom.g:28129:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalRoom.g:27870:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalRoom.g:28129:24: (~ ( ( '\\n' | '\\r' ) ) )*
             loop11:
             do {
                 int alt11=2;
@@ -3182,7 +3182,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt11) {
             	case 1 :
-            	    // InternalRoom.g:27870:24: ~ ( ( '\\n' | '\\r' ) )
+            	    // InternalRoom.g:28129:24: ~ ( ( '\\n' | '\\r' ) )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -3202,7 +3202,7 @@ public class InternalRoomLexer extends Lexer {
                 }
             } while (true);
 
-            // InternalRoom.g:27870:40: ( ( '\\r' )? '\\n' )?
+            // InternalRoom.g:28129:40: ( ( '\\r' )? '\\n' )?
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -3211,9 +3211,9 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalRoom.g:27870:41: ( '\\r' )? '\\n'
+                    // InternalRoom.g:28129:41: ( '\\r' )? '\\n'
                     {
-                    // InternalRoom.g:27870:41: ( '\\r' )?
+                    // InternalRoom.g:28129:41: ( '\\r' )?
                     int alt12=2;
                     int LA12_0 = input.LA(1);
 
@@ -3222,7 +3222,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     switch (alt12) {
                         case 1 :
-                            // InternalRoom.g:27870:41: '\\r'
+                            // InternalRoom.g:28129:41: '\\r'
                             {
                             match('\r'); 
 
@@ -3254,10 +3254,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_WS;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27872:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
-            // InternalRoom.g:27872:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:28131:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalRoom.g:28131:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalRoom.g:27872:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:28131:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             int cnt14=0;
             loop14:
             do {
@@ -3311,8 +3311,8 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ANY_OTHER;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:27874:16: ( . )
-            // InternalRoom.g:27874:18: .
+            // InternalRoom.g:28133:16: ( . )
+            // InternalRoom.g:28133:18: .
             {
             matchAny(); 
 
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomParser.java b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomParser.java
index e1cc5c702..c1da5b101 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomParser.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoomParser.java
@@ -500,12 +500,89 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "ruleVarDecl"
 
 
+    // $ANTLR start "entryRuleMessageData"
+    // InternalRoom.g:174:1: entryRuleMessageData : ruleMessageData EOF ;
+    public final void entryRuleMessageData() throws RecognitionException {
+        try {
+            // InternalRoom.g:175:1: ( ruleMessageData EOF )
+            // InternalRoom.g:176:1: ruleMessageData EOF
+            {
+             before(grammarAccess.getMessageDataRule()); 
+            pushFollow(FOLLOW_1);
+            ruleMessageData();
+
+            state._fsp--;
+
+             after(grammarAccess.getMessageDataRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleMessageData"
+
+
+    // $ANTLR start "ruleMessageData"
+    // InternalRoom.g:183:1: ruleMessageData : ( ( rule__MessageData__Group__0 ) ) ;
+    public final void ruleMessageData() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:187:2: ( ( ( rule__MessageData__Group__0 ) ) )
+            // InternalRoom.g:188:1: ( ( rule__MessageData__Group__0 ) )
+            {
+            // InternalRoom.g:188:1: ( ( rule__MessageData__Group__0 ) )
+            // InternalRoom.g:189:1: ( rule__MessageData__Group__0 )
+            {
+             before(grammarAccess.getMessageDataAccess().getGroup()); 
+            // InternalRoom.g:190:1: ( rule__MessageData__Group__0 )
+            // InternalRoom.g:190:2: rule__MessageData__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__MessageData__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMessageDataAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleMessageData"
+
+
     // $ANTLR start "entryRuleRefableType"
-    // InternalRoom.g:174:1: entryRuleRefableType : ruleRefableType EOF ;
+    // InternalRoom.g:202:1: entryRuleRefableType : ruleRefableType EOF ;
     public final void entryRuleRefableType() throws RecognitionException {
         try {
-            // InternalRoom.g:175:1: ( ruleRefableType EOF )
-            // InternalRoom.g:176:1: ruleRefableType EOF
+            // InternalRoom.g:203:1: ( ruleRefableType EOF )
+            // InternalRoom.g:204:1: ruleRefableType EOF
             {
              before(grammarAccess.getRefableTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -531,21 +608,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefableType"
-    // InternalRoom.g:183:1: ruleRefableType : ( ( rule__RefableType__Group__0 ) ) ;
+    // InternalRoom.g:211:1: ruleRefableType : ( ( rule__RefableType__Group__0 ) ) ;
     public final void ruleRefableType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:187:2: ( ( ( rule__RefableType__Group__0 ) ) )
-            // InternalRoom.g:188:1: ( ( rule__RefableType__Group__0 ) )
+            // InternalRoom.g:215:2: ( ( ( rule__RefableType__Group__0 ) ) )
+            // InternalRoom.g:216:1: ( ( rule__RefableType__Group__0 ) )
             {
-            // InternalRoom.g:188:1: ( ( rule__RefableType__Group__0 ) )
-            // InternalRoom.g:189:1: ( rule__RefableType__Group__0 )
+            // InternalRoom.g:216:1: ( ( rule__RefableType__Group__0 ) )
+            // InternalRoom.g:217:1: ( rule__RefableType__Group__0 )
             {
              before(grammarAccess.getRefableTypeAccess().getGroup()); 
-            // InternalRoom.g:190:1: ( rule__RefableType__Group__0 )
-            // InternalRoom.g:190:2: rule__RefableType__Group__0
+            // InternalRoom.g:218:1: ( rule__RefableType__Group__0 )
+            // InternalRoom.g:218:2: rule__RefableType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefableType__Group__0();
@@ -578,11 +655,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDataType"
-    // InternalRoom.g:202:1: entryRuleDataType : ruleDataType EOF ;
+    // InternalRoom.g:230:1: entryRuleDataType : ruleDataType EOF ;
     public final void entryRuleDataType() throws RecognitionException {
         try {
-            // InternalRoom.g:203:1: ( ruleDataType EOF )
-            // InternalRoom.g:204:1: ruleDataType EOF
+            // InternalRoom.g:231:1: ( ruleDataType EOF )
+            // InternalRoom.g:232:1: ruleDataType EOF
             {
              before(grammarAccess.getDataTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -608,21 +685,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDataType"
-    // InternalRoom.g:211:1: ruleDataType : ( ( rule__DataType__Alternatives ) ) ;
+    // InternalRoom.g:239:1: ruleDataType : ( ( rule__DataType__Alternatives ) ) ;
     public final void ruleDataType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:215:2: ( ( ( rule__DataType__Alternatives ) ) )
-            // InternalRoom.g:216:1: ( ( rule__DataType__Alternatives ) )
+            // InternalRoom.g:243:2: ( ( ( rule__DataType__Alternatives ) ) )
+            // InternalRoom.g:244:1: ( ( rule__DataType__Alternatives ) )
             {
-            // InternalRoom.g:216:1: ( ( rule__DataType__Alternatives ) )
-            // InternalRoom.g:217:1: ( rule__DataType__Alternatives )
+            // InternalRoom.g:244:1: ( ( rule__DataType__Alternatives ) )
+            // InternalRoom.g:245:1: ( rule__DataType__Alternatives )
             {
              before(grammarAccess.getDataTypeAccess().getAlternatives()); 
-            // InternalRoom.g:218:1: ( rule__DataType__Alternatives )
-            // InternalRoom.g:218:2: rule__DataType__Alternatives
+            // InternalRoom.g:246:1: ( rule__DataType__Alternatives )
+            // InternalRoom.g:246:2: rule__DataType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__DataType__Alternatives();
@@ -655,11 +732,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleComplexType"
-    // InternalRoom.g:230:1: entryRuleComplexType : ruleComplexType EOF ;
+    // InternalRoom.g:258:1: entryRuleComplexType : ruleComplexType EOF ;
     public final void entryRuleComplexType() throws RecognitionException {
         try {
-            // InternalRoom.g:231:1: ( ruleComplexType EOF )
-            // InternalRoom.g:232:1: ruleComplexType EOF
+            // InternalRoom.g:259:1: ( ruleComplexType EOF )
+            // InternalRoom.g:260:1: ruleComplexType EOF
             {
              before(grammarAccess.getComplexTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -685,21 +762,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleComplexType"
-    // InternalRoom.g:239:1: ruleComplexType : ( ( rule__ComplexType__Alternatives ) ) ;
+    // InternalRoom.g:267:1: ruleComplexType : ( ( rule__ComplexType__Alternatives ) ) ;
     public final void ruleComplexType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:243:2: ( ( ( rule__ComplexType__Alternatives ) ) )
-            // InternalRoom.g:244:1: ( ( rule__ComplexType__Alternatives ) )
+            // InternalRoom.g:271:2: ( ( ( rule__ComplexType__Alternatives ) ) )
+            // InternalRoom.g:272:1: ( ( rule__ComplexType__Alternatives ) )
             {
-            // InternalRoom.g:244:1: ( ( rule__ComplexType__Alternatives ) )
-            // InternalRoom.g:245:1: ( rule__ComplexType__Alternatives )
+            // InternalRoom.g:272:1: ( ( rule__ComplexType__Alternatives ) )
+            // InternalRoom.g:273:1: ( rule__ComplexType__Alternatives )
             {
              before(grammarAccess.getComplexTypeAccess().getAlternatives()); 
-            // InternalRoom.g:246:1: ( rule__ComplexType__Alternatives )
-            // InternalRoom.g:246:2: rule__ComplexType__Alternatives
+            // InternalRoom.g:274:1: ( rule__ComplexType__Alternatives )
+            // InternalRoom.g:274:2: rule__ComplexType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ComplexType__Alternatives();
@@ -732,11 +809,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRulePrimitiveType"
-    // InternalRoom.g:258:1: entryRulePrimitiveType : rulePrimitiveType EOF ;
+    // InternalRoom.g:286:1: entryRulePrimitiveType : rulePrimitiveType EOF ;
     public final void entryRulePrimitiveType() throws RecognitionException {
         try {
-            // InternalRoom.g:259:1: ( rulePrimitiveType EOF )
-            // InternalRoom.g:260:1: rulePrimitiveType EOF
+            // InternalRoom.g:287:1: ( rulePrimitiveType EOF )
+            // InternalRoom.g:288:1: rulePrimitiveType EOF
             {
              before(grammarAccess.getPrimitiveTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -762,21 +839,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rulePrimitiveType"
-    // InternalRoom.g:267:1: rulePrimitiveType : ( ( rule__PrimitiveType__Group__0 ) ) ;
+    // InternalRoom.g:295:1: rulePrimitiveType : ( ( rule__PrimitiveType__Group__0 ) ) ;
     public final void rulePrimitiveType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:271:2: ( ( ( rule__PrimitiveType__Group__0 ) ) )
-            // InternalRoom.g:272:1: ( ( rule__PrimitiveType__Group__0 ) )
+            // InternalRoom.g:299:2: ( ( ( rule__PrimitiveType__Group__0 ) ) )
+            // InternalRoom.g:300:1: ( ( rule__PrimitiveType__Group__0 ) )
             {
-            // InternalRoom.g:272:1: ( ( rule__PrimitiveType__Group__0 ) )
-            // InternalRoom.g:273:1: ( rule__PrimitiveType__Group__0 )
+            // InternalRoom.g:300:1: ( ( rule__PrimitiveType__Group__0 ) )
+            // InternalRoom.g:301:1: ( rule__PrimitiveType__Group__0 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getGroup()); 
-            // InternalRoom.g:274:1: ( rule__PrimitiveType__Group__0 )
-            // InternalRoom.g:274:2: rule__PrimitiveType__Group__0
+            // InternalRoom.g:302:1: ( rule__PrimitiveType__Group__0 )
+            // InternalRoom.g:302:2: rule__PrimitiveType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__Group__0();
@@ -809,11 +886,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEnumerationType"
-    // InternalRoom.g:286:1: entryRuleEnumerationType : ruleEnumerationType EOF ;
+    // InternalRoom.g:314:1: entryRuleEnumerationType : ruleEnumerationType EOF ;
     public final void entryRuleEnumerationType() throws RecognitionException {
         try {
-            // InternalRoom.g:287:1: ( ruleEnumerationType EOF )
-            // InternalRoom.g:288:1: ruleEnumerationType EOF
+            // InternalRoom.g:315:1: ( ruleEnumerationType EOF )
+            // InternalRoom.g:316:1: ruleEnumerationType EOF
             {
              before(grammarAccess.getEnumerationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -839,21 +916,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEnumerationType"
-    // InternalRoom.g:295:1: ruleEnumerationType : ( ( rule__EnumerationType__Group__0 ) ) ;
+    // InternalRoom.g:323:1: ruleEnumerationType : ( ( rule__EnumerationType__Group__0 ) ) ;
     public final void ruleEnumerationType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:299:2: ( ( ( rule__EnumerationType__Group__0 ) ) )
-            // InternalRoom.g:300:1: ( ( rule__EnumerationType__Group__0 ) )
+            // InternalRoom.g:327:2: ( ( ( rule__EnumerationType__Group__0 ) ) )
+            // InternalRoom.g:328:1: ( ( rule__EnumerationType__Group__0 ) )
             {
-            // InternalRoom.g:300:1: ( ( rule__EnumerationType__Group__0 ) )
-            // InternalRoom.g:301:1: ( rule__EnumerationType__Group__0 )
+            // InternalRoom.g:328:1: ( ( rule__EnumerationType__Group__0 ) )
+            // InternalRoom.g:329:1: ( rule__EnumerationType__Group__0 )
             {
              before(grammarAccess.getEnumerationTypeAccess().getGroup()); 
-            // InternalRoom.g:302:1: ( rule__EnumerationType__Group__0 )
-            // InternalRoom.g:302:2: rule__EnumerationType__Group__0
+            // InternalRoom.g:330:1: ( rule__EnumerationType__Group__0 )
+            // InternalRoom.g:330:2: rule__EnumerationType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group__0();
@@ -886,11 +963,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEnumLiteral"
-    // InternalRoom.g:314:1: entryRuleEnumLiteral : ruleEnumLiteral EOF ;
+    // InternalRoom.g:342:1: entryRuleEnumLiteral : ruleEnumLiteral EOF ;
     public final void entryRuleEnumLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:315:1: ( ruleEnumLiteral EOF )
-            // InternalRoom.g:316:1: ruleEnumLiteral EOF
+            // InternalRoom.g:343:1: ( ruleEnumLiteral EOF )
+            // InternalRoom.g:344:1: ruleEnumLiteral EOF
             {
              before(grammarAccess.getEnumLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -916,21 +993,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEnumLiteral"
-    // InternalRoom.g:323:1: ruleEnumLiteral : ( ( rule__EnumLiteral__Group__0 ) ) ;
+    // InternalRoom.g:351:1: ruleEnumLiteral : ( ( rule__EnumLiteral__Group__0 ) ) ;
     public final void ruleEnumLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:327:2: ( ( ( rule__EnumLiteral__Group__0 ) ) )
-            // InternalRoom.g:328:1: ( ( rule__EnumLiteral__Group__0 ) )
+            // InternalRoom.g:355:2: ( ( ( rule__EnumLiteral__Group__0 ) ) )
+            // InternalRoom.g:356:1: ( ( rule__EnumLiteral__Group__0 ) )
             {
-            // InternalRoom.g:328:1: ( ( rule__EnumLiteral__Group__0 ) )
-            // InternalRoom.g:329:1: ( rule__EnumLiteral__Group__0 )
+            // InternalRoom.g:356:1: ( ( rule__EnumLiteral__Group__0 ) )
+            // InternalRoom.g:357:1: ( rule__EnumLiteral__Group__0 )
             {
              before(grammarAccess.getEnumLiteralAccess().getGroup()); 
-            // InternalRoom.g:330:1: ( rule__EnumLiteral__Group__0 )
-            // InternalRoom.g:330:2: rule__EnumLiteral__Group__0
+            // InternalRoom.g:358:1: ( rule__EnumLiteral__Group__0 )
+            // InternalRoom.g:358:2: rule__EnumLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__Group__0();
@@ -963,11 +1040,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleExternalType"
-    // InternalRoom.g:342:1: entryRuleExternalType : ruleExternalType EOF ;
+    // InternalRoom.g:370:1: entryRuleExternalType : ruleExternalType EOF ;
     public final void entryRuleExternalType() throws RecognitionException {
         try {
-            // InternalRoom.g:343:1: ( ruleExternalType EOF )
-            // InternalRoom.g:344:1: ruleExternalType EOF
+            // InternalRoom.g:371:1: ( ruleExternalType EOF )
+            // InternalRoom.g:372:1: ruleExternalType EOF
             {
              before(grammarAccess.getExternalTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -993,21 +1070,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleExternalType"
-    // InternalRoom.g:351:1: ruleExternalType : ( ( rule__ExternalType__Group__0 ) ) ;
+    // InternalRoom.g:379:1: ruleExternalType : ( ( rule__ExternalType__Group__0 ) ) ;
     public final void ruleExternalType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:355:2: ( ( ( rule__ExternalType__Group__0 ) ) )
-            // InternalRoom.g:356:1: ( ( rule__ExternalType__Group__0 ) )
+            // InternalRoom.g:383:2: ( ( ( rule__ExternalType__Group__0 ) ) )
+            // InternalRoom.g:384:1: ( ( rule__ExternalType__Group__0 ) )
             {
-            // InternalRoom.g:356:1: ( ( rule__ExternalType__Group__0 ) )
-            // InternalRoom.g:357:1: ( rule__ExternalType__Group__0 )
+            // InternalRoom.g:384:1: ( ( rule__ExternalType__Group__0 ) )
+            // InternalRoom.g:385:1: ( rule__ExternalType__Group__0 )
             {
              before(grammarAccess.getExternalTypeAccess().getGroup()); 
-            // InternalRoom.g:358:1: ( rule__ExternalType__Group__0 )
-            // InternalRoom.g:358:2: rule__ExternalType__Group__0
+            // InternalRoom.g:386:1: ( rule__ExternalType__Group__0 )
+            // InternalRoom.g:386:2: rule__ExternalType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__Group__0();
@@ -1040,11 +1117,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDataClass"
-    // InternalRoom.g:370:1: entryRuleDataClass : ruleDataClass EOF ;
+    // InternalRoom.g:398:1: entryRuleDataClass : ruleDataClass EOF ;
     public final void entryRuleDataClass() throws RecognitionException {
         try {
-            // InternalRoom.g:371:1: ( ruleDataClass EOF )
-            // InternalRoom.g:372:1: ruleDataClass EOF
+            // InternalRoom.g:399:1: ( ruleDataClass EOF )
+            // InternalRoom.g:400:1: ruleDataClass EOF
             {
              before(grammarAccess.getDataClassRule()); 
             pushFollow(FOLLOW_1);
@@ -1070,21 +1147,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDataClass"
-    // InternalRoom.g:379:1: ruleDataClass : ( ( rule__DataClass__Group__0 ) ) ;
+    // InternalRoom.g:407:1: ruleDataClass : ( ( rule__DataClass__Group__0 ) ) ;
     public final void ruleDataClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:383:2: ( ( ( rule__DataClass__Group__0 ) ) )
-            // InternalRoom.g:384:1: ( ( rule__DataClass__Group__0 ) )
+            // InternalRoom.g:411:2: ( ( ( rule__DataClass__Group__0 ) ) )
+            // InternalRoom.g:412:1: ( ( rule__DataClass__Group__0 ) )
             {
-            // InternalRoom.g:384:1: ( ( rule__DataClass__Group__0 ) )
-            // InternalRoom.g:385:1: ( rule__DataClass__Group__0 )
+            // InternalRoom.g:412:1: ( ( rule__DataClass__Group__0 ) )
+            // InternalRoom.g:413:1: ( rule__DataClass__Group__0 )
             {
              before(grammarAccess.getDataClassAccess().getGroup()); 
-            // InternalRoom.g:386:1: ( rule__DataClass__Group__0 )
-            // InternalRoom.g:386:2: rule__DataClass__Group__0
+            // InternalRoom.g:414:1: ( rule__DataClass__Group__0 )
+            // InternalRoom.g:414:2: rule__DataClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group__0();
@@ -1117,11 +1194,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAttribute"
-    // InternalRoom.g:398:1: entryRuleAttribute : ruleAttribute EOF ;
+    // InternalRoom.g:426:1: entryRuleAttribute : ruleAttribute EOF ;
     public final void entryRuleAttribute() throws RecognitionException {
         try {
-            // InternalRoom.g:399:1: ( ruleAttribute EOF )
-            // InternalRoom.g:400:1: ruleAttribute EOF
+            // InternalRoom.g:427:1: ( ruleAttribute EOF )
+            // InternalRoom.g:428:1: ruleAttribute EOF
             {
              before(grammarAccess.getAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -1147,21 +1224,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAttribute"
-    // InternalRoom.g:407:1: ruleAttribute : ( ( rule__Attribute__Group__0 ) ) ;
+    // InternalRoom.g:435:1: ruleAttribute : ( ( rule__Attribute__Group__0 ) ) ;
     public final void ruleAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:411:2: ( ( ( rule__Attribute__Group__0 ) ) )
-            // InternalRoom.g:412:1: ( ( rule__Attribute__Group__0 ) )
+            // InternalRoom.g:439:2: ( ( ( rule__Attribute__Group__0 ) ) )
+            // InternalRoom.g:440:1: ( ( rule__Attribute__Group__0 ) )
             {
-            // InternalRoom.g:412:1: ( ( rule__Attribute__Group__0 ) )
-            // InternalRoom.g:413:1: ( rule__Attribute__Group__0 )
+            // InternalRoom.g:440:1: ( ( rule__Attribute__Group__0 ) )
+            // InternalRoom.g:441:1: ( rule__Attribute__Group__0 )
             {
              before(grammarAccess.getAttributeAccess().getGroup()); 
-            // InternalRoom.g:414:1: ( rule__Attribute__Group__0 )
-            // InternalRoom.g:414:2: rule__Attribute__Group__0
+            // InternalRoom.g:442:1: ( rule__Attribute__Group__0 )
+            // InternalRoom.g:442:2: rule__Attribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group__0();
@@ -1194,11 +1271,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStandardOperation"
-    // InternalRoom.g:428:1: entryRuleStandardOperation : ruleStandardOperation EOF ;
+    // InternalRoom.g:456:1: entryRuleStandardOperation : ruleStandardOperation EOF ;
     public final void entryRuleStandardOperation() throws RecognitionException {
         try {
-            // InternalRoom.g:429:1: ( ruleStandardOperation EOF )
-            // InternalRoom.g:430:1: ruleStandardOperation EOF
+            // InternalRoom.g:457:1: ( ruleStandardOperation EOF )
+            // InternalRoom.g:458:1: ruleStandardOperation EOF
             {
              before(grammarAccess.getStandardOperationRule()); 
             pushFollow(FOLLOW_1);
@@ -1224,21 +1301,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStandardOperation"
-    // InternalRoom.g:437:1: ruleStandardOperation : ( ( rule__StandardOperation__Group__0 ) ) ;
+    // InternalRoom.g:465:1: ruleStandardOperation : ( ( rule__StandardOperation__Group__0 ) ) ;
     public final void ruleStandardOperation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:441:2: ( ( ( rule__StandardOperation__Group__0 ) ) )
-            // InternalRoom.g:442:1: ( ( rule__StandardOperation__Group__0 ) )
+            // InternalRoom.g:469:2: ( ( ( rule__StandardOperation__Group__0 ) ) )
+            // InternalRoom.g:470:1: ( ( rule__StandardOperation__Group__0 ) )
             {
-            // InternalRoom.g:442:1: ( ( rule__StandardOperation__Group__0 ) )
-            // InternalRoom.g:443:1: ( rule__StandardOperation__Group__0 )
+            // InternalRoom.g:470:1: ( ( rule__StandardOperation__Group__0 ) )
+            // InternalRoom.g:471:1: ( rule__StandardOperation__Group__0 )
             {
              before(grammarAccess.getStandardOperationAccess().getGroup()); 
-            // InternalRoom.g:444:1: ( rule__StandardOperation__Group__0 )
-            // InternalRoom.g:444:2: rule__StandardOperation__Group__0
+            // InternalRoom.g:472:1: ( rule__StandardOperation__Group__0 )
+            // InternalRoom.g:472:2: rule__StandardOperation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group__0();
@@ -1271,11 +1348,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRulePortOperation"
-    // InternalRoom.g:456:1: entryRulePortOperation : rulePortOperation EOF ;
+    // InternalRoom.g:484:1: entryRulePortOperation : rulePortOperation EOF ;
     public final void entryRulePortOperation() throws RecognitionException {
         try {
-            // InternalRoom.g:457:1: ( rulePortOperation EOF )
-            // InternalRoom.g:458:1: rulePortOperation EOF
+            // InternalRoom.g:485:1: ( rulePortOperation EOF )
+            // InternalRoom.g:486:1: rulePortOperation EOF
             {
              before(grammarAccess.getPortOperationRule()); 
             pushFollow(FOLLOW_1);
@@ -1301,21 +1378,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rulePortOperation"
-    // InternalRoom.g:465:1: rulePortOperation : ( ( rule__PortOperation__Group__0 ) ) ;
+    // InternalRoom.g:493:1: rulePortOperation : ( ( rule__PortOperation__Group__0 ) ) ;
     public final void rulePortOperation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:469:2: ( ( ( rule__PortOperation__Group__0 ) ) )
-            // InternalRoom.g:470:1: ( ( rule__PortOperation__Group__0 ) )
+            // InternalRoom.g:497:2: ( ( ( rule__PortOperation__Group__0 ) ) )
+            // InternalRoom.g:498:1: ( ( rule__PortOperation__Group__0 ) )
             {
-            // InternalRoom.g:470:1: ( ( rule__PortOperation__Group__0 ) )
-            // InternalRoom.g:471:1: ( rule__PortOperation__Group__0 )
+            // InternalRoom.g:498:1: ( ( rule__PortOperation__Group__0 ) )
+            // InternalRoom.g:499:1: ( rule__PortOperation__Group__0 )
             {
              before(grammarAccess.getPortOperationAccess().getGroup()); 
-            // InternalRoom.g:472:1: ( rule__PortOperation__Group__0 )
-            // InternalRoom.g:472:2: rule__PortOperation__Group__0
+            // InternalRoom.g:500:1: ( rule__PortOperation__Group__0 )
+            // InternalRoom.g:500:2: rule__PortOperation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group__0();
@@ -1348,11 +1425,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleClassStructor"
-    // InternalRoom.g:484:1: entryRuleClassStructor : ruleClassStructor EOF ;
+    // InternalRoom.g:512:1: entryRuleClassStructor : ruleClassStructor EOF ;
     public final void entryRuleClassStructor() throws RecognitionException {
         try {
-            // InternalRoom.g:485:1: ( ruleClassStructor EOF )
-            // InternalRoom.g:486:1: ruleClassStructor EOF
+            // InternalRoom.g:513:1: ( ruleClassStructor EOF )
+            // InternalRoom.g:514:1: ruleClassStructor EOF
             {
              before(grammarAccess.getClassStructorRule()); 
             pushFollow(FOLLOW_1);
@@ -1378,21 +1455,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleClassStructor"
-    // InternalRoom.g:493:1: ruleClassStructor : ( ( rule__ClassStructor__Group__0 ) ) ;
+    // InternalRoom.g:521:1: ruleClassStructor : ( ( rule__ClassStructor__Group__0 ) ) ;
     public final void ruleClassStructor() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:497:2: ( ( ( rule__ClassStructor__Group__0 ) ) )
-            // InternalRoom.g:498:1: ( ( rule__ClassStructor__Group__0 ) )
+            // InternalRoom.g:525:2: ( ( ( rule__ClassStructor__Group__0 ) ) )
+            // InternalRoom.g:526:1: ( ( rule__ClassStructor__Group__0 ) )
             {
-            // InternalRoom.g:498:1: ( ( rule__ClassStructor__Group__0 ) )
-            // InternalRoom.g:499:1: ( rule__ClassStructor__Group__0 )
+            // InternalRoom.g:526:1: ( ( rule__ClassStructor__Group__0 ) )
+            // InternalRoom.g:527:1: ( rule__ClassStructor__Group__0 )
             {
              before(grammarAccess.getClassStructorAccess().getGroup()); 
-            // InternalRoom.g:500:1: ( rule__ClassStructor__Group__0 )
-            // InternalRoom.g:500:2: rule__ClassStructor__Group__0
+            // InternalRoom.g:528:1: ( rule__ClassStructor__Group__0 )
+            // InternalRoom.g:528:2: rule__ClassStructor__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__Group__0();
@@ -1425,11 +1502,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGeneralProtocolClass"
-    // InternalRoom.g:512:1: entryRuleGeneralProtocolClass : ruleGeneralProtocolClass EOF ;
+    // InternalRoom.g:540:1: entryRuleGeneralProtocolClass : ruleGeneralProtocolClass EOF ;
     public final void entryRuleGeneralProtocolClass() throws RecognitionException {
         try {
-            // InternalRoom.g:513:1: ( ruleGeneralProtocolClass EOF )
-            // InternalRoom.g:514:1: ruleGeneralProtocolClass EOF
+            // InternalRoom.g:541:1: ( ruleGeneralProtocolClass EOF )
+            // InternalRoom.g:542:1: ruleGeneralProtocolClass EOF
             {
              before(grammarAccess.getGeneralProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -1455,21 +1532,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGeneralProtocolClass"
-    // InternalRoom.g:521:1: ruleGeneralProtocolClass : ( ( rule__GeneralProtocolClass__Alternatives ) ) ;
+    // InternalRoom.g:549:1: ruleGeneralProtocolClass : ( ( rule__GeneralProtocolClass__Alternatives ) ) ;
     public final void ruleGeneralProtocolClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:525:2: ( ( ( rule__GeneralProtocolClass__Alternatives ) ) )
-            // InternalRoom.g:526:1: ( ( rule__GeneralProtocolClass__Alternatives ) )
+            // InternalRoom.g:553:2: ( ( ( rule__GeneralProtocolClass__Alternatives ) ) )
+            // InternalRoom.g:554:1: ( ( rule__GeneralProtocolClass__Alternatives ) )
             {
-            // InternalRoom.g:526:1: ( ( rule__GeneralProtocolClass__Alternatives ) )
-            // InternalRoom.g:527:1: ( rule__GeneralProtocolClass__Alternatives )
+            // InternalRoom.g:554:1: ( ( rule__GeneralProtocolClass__Alternatives ) )
+            // InternalRoom.g:555:1: ( rule__GeneralProtocolClass__Alternatives )
             {
              before(grammarAccess.getGeneralProtocolClassAccess().getAlternatives()); 
-            // InternalRoom.g:528:1: ( rule__GeneralProtocolClass__Alternatives )
-            // InternalRoom.g:528:2: rule__GeneralProtocolClass__Alternatives
+            // InternalRoom.g:556:1: ( rule__GeneralProtocolClass__Alternatives )
+            // InternalRoom.g:556:2: rule__GeneralProtocolClass__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__GeneralProtocolClass__Alternatives();
@@ -1502,11 +1579,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleProtocolClass"
-    // InternalRoom.g:540:1: entryRuleProtocolClass : ruleProtocolClass EOF ;
+    // InternalRoom.g:568:1: entryRuleProtocolClass : ruleProtocolClass EOF ;
     public final void entryRuleProtocolClass() throws RecognitionException {
         try {
-            // InternalRoom.g:541:1: ( ruleProtocolClass EOF )
-            // InternalRoom.g:542:1: ruleProtocolClass EOF
+            // InternalRoom.g:569:1: ( ruleProtocolClass EOF )
+            // InternalRoom.g:570:1: ruleProtocolClass EOF
             {
              before(grammarAccess.getProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -1532,21 +1609,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleProtocolClass"
-    // InternalRoom.g:549:1: ruleProtocolClass : ( ( rule__ProtocolClass__Group__0 ) ) ;
+    // InternalRoom.g:577:1: ruleProtocolClass : ( ( rule__ProtocolClass__Group__0 ) ) ;
     public final void ruleProtocolClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:553:2: ( ( ( rule__ProtocolClass__Group__0 ) ) )
-            // InternalRoom.g:554:1: ( ( rule__ProtocolClass__Group__0 ) )
+            // InternalRoom.g:581:2: ( ( ( rule__ProtocolClass__Group__0 ) ) )
+            // InternalRoom.g:582:1: ( ( rule__ProtocolClass__Group__0 ) )
             {
-            // InternalRoom.g:554:1: ( ( rule__ProtocolClass__Group__0 ) )
-            // InternalRoom.g:555:1: ( rule__ProtocolClass__Group__0 )
+            // InternalRoom.g:582:1: ( ( rule__ProtocolClass__Group__0 ) )
+            // InternalRoom.g:583:1: ( rule__ProtocolClass__Group__0 )
             {
              before(grammarAccess.getProtocolClassAccess().getGroup()); 
-            // InternalRoom.g:556:1: ( rule__ProtocolClass__Group__0 )
-            // InternalRoom.g:556:2: rule__ProtocolClass__Group__0
+            // InternalRoom.g:584:1: ( rule__ProtocolClass__Group__0 )
+            // InternalRoom.g:584:2: rule__ProtocolClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group__0();
@@ -1579,11 +1656,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleCompoundProtocolClass"
-    // InternalRoom.g:568:1: entryRuleCompoundProtocolClass : ruleCompoundProtocolClass EOF ;
+    // InternalRoom.g:596:1: entryRuleCompoundProtocolClass : ruleCompoundProtocolClass EOF ;
     public final void entryRuleCompoundProtocolClass() throws RecognitionException {
         try {
-            // InternalRoom.g:569:1: ( ruleCompoundProtocolClass EOF )
-            // InternalRoom.g:570:1: ruleCompoundProtocolClass EOF
+            // InternalRoom.g:597:1: ( ruleCompoundProtocolClass EOF )
+            // InternalRoom.g:598:1: ruleCompoundProtocolClass EOF
             {
              before(grammarAccess.getCompoundProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -1609,21 +1686,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCompoundProtocolClass"
-    // InternalRoom.g:577:1: ruleCompoundProtocolClass : ( ( rule__CompoundProtocolClass__Group__0 ) ) ;
+    // InternalRoom.g:605:1: ruleCompoundProtocolClass : ( ( rule__CompoundProtocolClass__Group__0 ) ) ;
     public final void ruleCompoundProtocolClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:581:2: ( ( ( rule__CompoundProtocolClass__Group__0 ) ) )
-            // InternalRoom.g:582:1: ( ( rule__CompoundProtocolClass__Group__0 ) )
+            // InternalRoom.g:609:2: ( ( ( rule__CompoundProtocolClass__Group__0 ) ) )
+            // InternalRoom.g:610:1: ( ( rule__CompoundProtocolClass__Group__0 ) )
             {
-            // InternalRoom.g:582:1: ( ( rule__CompoundProtocolClass__Group__0 ) )
-            // InternalRoom.g:583:1: ( rule__CompoundProtocolClass__Group__0 )
+            // InternalRoom.g:610:1: ( ( rule__CompoundProtocolClass__Group__0 ) )
+            // InternalRoom.g:611:1: ( rule__CompoundProtocolClass__Group__0 )
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getGroup()); 
-            // InternalRoom.g:584:1: ( rule__CompoundProtocolClass__Group__0 )
-            // InternalRoom.g:584:2: rule__CompoundProtocolClass__Group__0
+            // InternalRoom.g:612:1: ( rule__CompoundProtocolClass__Group__0 )
+            // InternalRoom.g:612:2: rule__CompoundProtocolClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__CompoundProtocolClass__Group__0();
@@ -1656,11 +1733,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubProtocol"
-    // InternalRoom.g:596:1: entryRuleSubProtocol : ruleSubProtocol EOF ;
+    // InternalRoom.g:624:1: entryRuleSubProtocol : ruleSubProtocol EOF ;
     public final void entryRuleSubProtocol() throws RecognitionException {
         try {
-            // InternalRoom.g:597:1: ( ruleSubProtocol EOF )
-            // InternalRoom.g:598:1: ruleSubProtocol EOF
+            // InternalRoom.g:625:1: ( ruleSubProtocol EOF )
+            // InternalRoom.g:626:1: ruleSubProtocol EOF
             {
              before(grammarAccess.getSubProtocolRule()); 
             pushFollow(FOLLOW_1);
@@ -1686,21 +1763,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubProtocol"
-    // InternalRoom.g:605:1: ruleSubProtocol : ( ( rule__SubProtocol__Group__0 ) ) ;
+    // InternalRoom.g:633:1: ruleSubProtocol : ( ( rule__SubProtocol__Group__0 ) ) ;
     public final void ruleSubProtocol() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:609:2: ( ( ( rule__SubProtocol__Group__0 ) ) )
-            // InternalRoom.g:610:1: ( ( rule__SubProtocol__Group__0 ) )
+            // InternalRoom.g:637:2: ( ( ( rule__SubProtocol__Group__0 ) ) )
+            // InternalRoom.g:638:1: ( ( rule__SubProtocol__Group__0 ) )
             {
-            // InternalRoom.g:610:1: ( ( rule__SubProtocol__Group__0 ) )
-            // InternalRoom.g:611:1: ( rule__SubProtocol__Group__0 )
+            // InternalRoom.g:638:1: ( ( rule__SubProtocol__Group__0 ) )
+            // InternalRoom.g:639:1: ( rule__SubProtocol__Group__0 )
             {
              before(grammarAccess.getSubProtocolAccess().getGroup()); 
-            // InternalRoom.g:612:1: ( rule__SubProtocol__Group__0 )
-            // InternalRoom.g:612:2: rule__SubProtocol__Group__0
+            // InternalRoom.g:640:1: ( rule__SubProtocol__Group__0 )
+            // InternalRoom.g:640:2: rule__SubProtocol__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__Group__0();
@@ -1733,11 +1810,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMessage"
-    // InternalRoom.g:624:1: entryRuleMessage : ruleMessage EOF ;
+    // InternalRoom.g:652:1: entryRuleMessage : ruleMessage EOF ;
     public final void entryRuleMessage() throws RecognitionException {
         try {
-            // InternalRoom.g:625:1: ( ruleMessage EOF )
-            // InternalRoom.g:626:1: ruleMessage EOF
+            // InternalRoom.g:653:1: ( ruleMessage EOF )
+            // InternalRoom.g:654:1: ruleMessage EOF
             {
              before(grammarAccess.getMessageRule()); 
             pushFollow(FOLLOW_1);
@@ -1763,21 +1840,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMessage"
-    // InternalRoom.g:633:1: ruleMessage : ( ( rule__Message__Group__0 ) ) ;
+    // InternalRoom.g:661:1: ruleMessage : ( ( rule__Message__Group__0 ) ) ;
     public final void ruleMessage() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:637:2: ( ( ( rule__Message__Group__0 ) ) )
-            // InternalRoom.g:638:1: ( ( rule__Message__Group__0 ) )
+            // InternalRoom.g:665:2: ( ( ( rule__Message__Group__0 ) ) )
+            // InternalRoom.g:666:1: ( ( rule__Message__Group__0 ) )
             {
-            // InternalRoom.g:638:1: ( ( rule__Message__Group__0 ) )
-            // InternalRoom.g:639:1: ( rule__Message__Group__0 )
+            // InternalRoom.g:666:1: ( ( rule__Message__Group__0 ) )
+            // InternalRoom.g:667:1: ( rule__Message__Group__0 )
             {
              before(grammarAccess.getMessageAccess().getGroup()); 
-            // InternalRoom.g:640:1: ( rule__Message__Group__0 )
-            // InternalRoom.g:640:2: rule__Message__Group__0
+            // InternalRoom.g:668:1: ( rule__Message__Group__0 )
+            // InternalRoom.g:668:2: rule__Message__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Message__Group__0();
@@ -1810,11 +1887,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRulePortClass"
-    // InternalRoom.g:652:1: entryRulePortClass : rulePortClass EOF ;
+    // InternalRoom.g:680:1: entryRulePortClass : rulePortClass EOF ;
     public final void entryRulePortClass() throws RecognitionException {
         try {
-            // InternalRoom.g:653:1: ( rulePortClass EOF )
-            // InternalRoom.g:654:1: rulePortClass EOF
+            // InternalRoom.g:681:1: ( rulePortClass EOF )
+            // InternalRoom.g:682:1: rulePortClass EOF
             {
              before(grammarAccess.getPortClassRule()); 
             pushFollow(FOLLOW_1);
@@ -1840,21 +1917,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rulePortClass"
-    // InternalRoom.g:661:1: rulePortClass : ( ( rule__PortClass__Group__0 ) ) ;
+    // InternalRoom.g:689:1: rulePortClass : ( ( rule__PortClass__Group__0 ) ) ;
     public final void rulePortClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:665:2: ( ( ( rule__PortClass__Group__0 ) ) )
-            // InternalRoom.g:666:1: ( ( rule__PortClass__Group__0 ) )
+            // InternalRoom.g:693:2: ( ( ( rule__PortClass__Group__0 ) ) )
+            // InternalRoom.g:694:1: ( ( rule__PortClass__Group__0 ) )
             {
-            // InternalRoom.g:666:1: ( ( rule__PortClass__Group__0 ) )
-            // InternalRoom.g:667:1: ( rule__PortClass__Group__0 )
+            // InternalRoom.g:694:1: ( ( rule__PortClass__Group__0 ) )
+            // InternalRoom.g:695:1: ( rule__PortClass__Group__0 )
             {
              before(grammarAccess.getPortClassAccess().getGroup()); 
-            // InternalRoom.g:668:1: ( rule__PortClass__Group__0 )
-            // InternalRoom.g:668:2: rule__PortClass__Group__0
+            // InternalRoom.g:696:1: ( rule__PortClass__Group__0 )
+            // InternalRoom.g:696:2: rule__PortClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__Group__0();
@@ -1887,11 +1964,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMessageHandler"
-    // InternalRoom.g:680:1: entryRuleMessageHandler : ruleMessageHandler EOF ;
+    // InternalRoom.g:708:1: entryRuleMessageHandler : ruleMessageHandler EOF ;
     public final void entryRuleMessageHandler() throws RecognitionException {
         try {
-            // InternalRoom.g:681:1: ( ruleMessageHandler EOF )
-            // InternalRoom.g:682:1: ruleMessageHandler EOF
+            // InternalRoom.g:709:1: ( ruleMessageHandler EOF )
+            // InternalRoom.g:710:1: ruleMessageHandler EOF
             {
              before(grammarAccess.getMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -1917,21 +1994,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMessageHandler"
-    // InternalRoom.g:689:1: ruleMessageHandler : ( ( rule__MessageHandler__Alternatives ) ) ;
+    // InternalRoom.g:717:1: ruleMessageHandler : ( ( rule__MessageHandler__Alternatives ) ) ;
     public final void ruleMessageHandler() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:693:2: ( ( ( rule__MessageHandler__Alternatives ) ) )
-            // InternalRoom.g:694:1: ( ( rule__MessageHandler__Alternatives ) )
+            // InternalRoom.g:721:2: ( ( ( rule__MessageHandler__Alternatives ) ) )
+            // InternalRoom.g:722:1: ( ( rule__MessageHandler__Alternatives ) )
             {
-            // InternalRoom.g:694:1: ( ( rule__MessageHandler__Alternatives ) )
-            // InternalRoom.g:695:1: ( rule__MessageHandler__Alternatives )
+            // InternalRoom.g:722:1: ( ( rule__MessageHandler__Alternatives ) )
+            // InternalRoom.g:723:1: ( rule__MessageHandler__Alternatives )
             {
              before(grammarAccess.getMessageHandlerAccess().getAlternatives()); 
-            // InternalRoom.g:696:1: ( rule__MessageHandler__Alternatives )
-            // InternalRoom.g:696:2: rule__MessageHandler__Alternatives
+            // InternalRoom.g:724:1: ( rule__MessageHandler__Alternatives )
+            // InternalRoom.g:724:2: rule__MessageHandler__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__MessageHandler__Alternatives();
@@ -1964,11 +2041,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInMessageHandler"
-    // InternalRoom.g:708:1: entryRuleInMessageHandler : ruleInMessageHandler EOF ;
+    // InternalRoom.g:736:1: entryRuleInMessageHandler : ruleInMessageHandler EOF ;
     public final void entryRuleInMessageHandler() throws RecognitionException {
         try {
-            // InternalRoom.g:709:1: ( ruleInMessageHandler EOF )
-            // InternalRoom.g:710:1: ruleInMessageHandler EOF
+            // InternalRoom.g:737:1: ( ruleInMessageHandler EOF )
+            // InternalRoom.g:738:1: ruleInMessageHandler EOF
             {
              before(grammarAccess.getInMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -1994,21 +2071,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInMessageHandler"
-    // InternalRoom.g:717:1: ruleInMessageHandler : ( ( rule__InMessageHandler__Group__0 ) ) ;
+    // InternalRoom.g:745:1: ruleInMessageHandler : ( ( rule__InMessageHandler__Group__0 ) ) ;
     public final void ruleInMessageHandler() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:721:2: ( ( ( rule__InMessageHandler__Group__0 ) ) )
-            // InternalRoom.g:722:1: ( ( rule__InMessageHandler__Group__0 ) )
+            // InternalRoom.g:749:2: ( ( ( rule__InMessageHandler__Group__0 ) ) )
+            // InternalRoom.g:750:1: ( ( rule__InMessageHandler__Group__0 ) )
             {
-            // InternalRoom.g:722:1: ( ( rule__InMessageHandler__Group__0 ) )
-            // InternalRoom.g:723:1: ( rule__InMessageHandler__Group__0 )
+            // InternalRoom.g:750:1: ( ( rule__InMessageHandler__Group__0 ) )
+            // InternalRoom.g:751:1: ( rule__InMessageHandler__Group__0 )
             {
              before(grammarAccess.getInMessageHandlerAccess().getGroup()); 
-            // InternalRoom.g:724:1: ( rule__InMessageHandler__Group__0 )
-            // InternalRoom.g:724:2: rule__InMessageHandler__Group__0
+            // InternalRoom.g:752:1: ( rule__InMessageHandler__Group__0 )
+            // InternalRoom.g:752:2: rule__InMessageHandler__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__Group__0();
@@ -2041,11 +2118,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleOutMessageHandler"
-    // InternalRoom.g:736:1: entryRuleOutMessageHandler : ruleOutMessageHandler EOF ;
+    // InternalRoom.g:764:1: entryRuleOutMessageHandler : ruleOutMessageHandler EOF ;
     public final void entryRuleOutMessageHandler() throws RecognitionException {
         try {
-            // InternalRoom.g:737:1: ( ruleOutMessageHandler EOF )
-            // InternalRoom.g:738:1: ruleOutMessageHandler EOF
+            // InternalRoom.g:765:1: ( ruleOutMessageHandler EOF )
+            // InternalRoom.g:766:1: ruleOutMessageHandler EOF
             {
              before(grammarAccess.getOutMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -2071,21 +2148,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleOutMessageHandler"
-    // InternalRoom.g:745:1: ruleOutMessageHandler : ( ( rule__OutMessageHandler__Group__0 ) ) ;
+    // InternalRoom.g:773:1: ruleOutMessageHandler : ( ( rule__OutMessageHandler__Group__0 ) ) ;
     public final void ruleOutMessageHandler() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:749:2: ( ( ( rule__OutMessageHandler__Group__0 ) ) )
-            // InternalRoom.g:750:1: ( ( rule__OutMessageHandler__Group__0 ) )
+            // InternalRoom.g:777:2: ( ( ( rule__OutMessageHandler__Group__0 ) ) )
+            // InternalRoom.g:778:1: ( ( rule__OutMessageHandler__Group__0 ) )
             {
-            // InternalRoom.g:750:1: ( ( rule__OutMessageHandler__Group__0 ) )
-            // InternalRoom.g:751:1: ( rule__OutMessageHandler__Group__0 )
+            // InternalRoom.g:778:1: ( ( rule__OutMessageHandler__Group__0 ) )
+            // InternalRoom.g:779:1: ( rule__OutMessageHandler__Group__0 )
             {
              before(grammarAccess.getOutMessageHandlerAccess().getGroup()); 
-            // InternalRoom.g:752:1: ( rule__OutMessageHandler__Group__0 )
-            // InternalRoom.g:752:2: rule__OutMessageHandler__Group__0
+            // InternalRoom.g:780:1: ( rule__OutMessageHandler__Group__0 )
+            // InternalRoom.g:780:2: rule__OutMessageHandler__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__Group__0();
@@ -2118,11 +2195,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleModelComponent"
-    // InternalRoom.g:764:1: entryRuleModelComponent : ruleModelComponent EOF ;
+    // InternalRoom.g:792:1: entryRuleModelComponent : ruleModelComponent EOF ;
     public final void entryRuleModelComponent() throws RecognitionException {
         try {
-            // InternalRoom.g:765:1: ( ruleModelComponent EOF )
-            // InternalRoom.g:766:1: ruleModelComponent EOF
+            // InternalRoom.g:793:1: ( ruleModelComponent EOF )
+            // InternalRoom.g:794:1: ruleModelComponent EOF
             {
              before(grammarAccess.getModelComponentRule()); 
             pushFollow(FOLLOW_1);
@@ -2148,17 +2225,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleModelComponent"
-    // InternalRoom.g:773:1: ruleModelComponent : ( ruleActorClass ) ;
+    // InternalRoom.g:801:1: ruleModelComponent : ( ruleActorClass ) ;
     public final void ruleModelComponent() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:777:2: ( ( ruleActorClass ) )
-            // InternalRoom.g:778:1: ( ruleActorClass )
+            // InternalRoom.g:805:2: ( ( ruleActorClass ) )
+            // InternalRoom.g:806:1: ( ruleActorClass )
             {
-            // InternalRoom.g:778:1: ( ruleActorClass )
-            // InternalRoom.g:779:1: ruleActorClass
+            // InternalRoom.g:806:1: ( ruleActorClass )
+            // InternalRoom.g:807:1: ruleActorClass
             {
              before(grammarAccess.getModelComponentAccess().getActorClassParserRuleCall()); 
             pushFollow(FOLLOW_2);
@@ -2189,11 +2266,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleActorClass"
-    // InternalRoom.g:792:1: entryRuleActorClass : ruleActorClass EOF ;
+    // InternalRoom.g:820:1: entryRuleActorClass : ruleActorClass EOF ;
     public final void entryRuleActorClass() throws RecognitionException {
         try {
-            // InternalRoom.g:793:1: ( ruleActorClass EOF )
-            // InternalRoom.g:794:1: ruleActorClass EOF
+            // InternalRoom.g:821:1: ( ruleActorClass EOF )
+            // InternalRoom.g:822:1: ruleActorClass EOF
             {
              before(grammarAccess.getActorClassRule()); 
             pushFollow(FOLLOW_1);
@@ -2219,21 +2296,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleActorClass"
-    // InternalRoom.g:801:1: ruleActorClass : ( ( rule__ActorClass__Group__0 ) ) ;
+    // InternalRoom.g:829:1: ruleActorClass : ( ( rule__ActorClass__Group__0 ) ) ;
     public final void ruleActorClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:805:2: ( ( ( rule__ActorClass__Group__0 ) ) )
-            // InternalRoom.g:806:1: ( ( rule__ActorClass__Group__0 ) )
+            // InternalRoom.g:833:2: ( ( ( rule__ActorClass__Group__0 ) ) )
+            // InternalRoom.g:834:1: ( ( rule__ActorClass__Group__0 ) )
             {
-            // InternalRoom.g:806:1: ( ( rule__ActorClass__Group__0 ) )
-            // InternalRoom.g:807:1: ( rule__ActorClass__Group__0 )
+            // InternalRoom.g:834:1: ( ( rule__ActorClass__Group__0 ) )
+            // InternalRoom.g:835:1: ( rule__ActorClass__Group__0 )
             {
              before(grammarAccess.getActorClassAccess().getGroup()); 
-            // InternalRoom.g:808:1: ( rule__ActorClass__Group__0 )
-            // InternalRoom.g:808:2: rule__ActorClass__Group__0
+            // InternalRoom.g:836:1: ( rule__ActorClass__Group__0 )
+            // InternalRoom.g:836:2: rule__ActorClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group__0();
@@ -2266,11 +2343,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInterfaceItem"
-    // InternalRoom.g:820:1: entryRuleInterfaceItem : ruleInterfaceItem EOF ;
+    // InternalRoom.g:848:1: entryRuleInterfaceItem : ruleInterfaceItem EOF ;
     public final void entryRuleInterfaceItem() throws RecognitionException {
         try {
-            // InternalRoom.g:821:1: ( ruleInterfaceItem EOF )
-            // InternalRoom.g:822:1: ruleInterfaceItem EOF
+            // InternalRoom.g:849:1: ( ruleInterfaceItem EOF )
+            // InternalRoom.g:850:1: ruleInterfaceItem EOF
             {
              before(grammarAccess.getInterfaceItemRule()); 
             pushFollow(FOLLOW_1);
@@ -2296,21 +2373,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInterfaceItem"
-    // InternalRoom.g:829:1: ruleInterfaceItem : ( ( rule__InterfaceItem__Alternatives ) ) ;
+    // InternalRoom.g:857:1: ruleInterfaceItem : ( ( rule__InterfaceItem__Alternatives ) ) ;
     public final void ruleInterfaceItem() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:833:2: ( ( ( rule__InterfaceItem__Alternatives ) ) )
-            // InternalRoom.g:834:1: ( ( rule__InterfaceItem__Alternatives ) )
+            // InternalRoom.g:861:2: ( ( ( rule__InterfaceItem__Alternatives ) ) )
+            // InternalRoom.g:862:1: ( ( rule__InterfaceItem__Alternatives ) )
             {
-            // InternalRoom.g:834:1: ( ( rule__InterfaceItem__Alternatives ) )
-            // InternalRoom.g:835:1: ( rule__InterfaceItem__Alternatives )
+            // InternalRoom.g:862:1: ( ( rule__InterfaceItem__Alternatives ) )
+            // InternalRoom.g:863:1: ( rule__InterfaceItem__Alternatives )
             {
              before(grammarAccess.getInterfaceItemAccess().getAlternatives()); 
-            // InternalRoom.g:836:1: ( rule__InterfaceItem__Alternatives )
-            // InternalRoom.g:836:2: rule__InterfaceItem__Alternatives
+            // InternalRoom.g:864:1: ( rule__InterfaceItem__Alternatives )
+            // InternalRoom.g:864:2: rule__InterfaceItem__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__InterfaceItem__Alternatives();
@@ -2343,11 +2420,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRulePort"
-    // InternalRoom.g:848:1: entryRulePort : rulePort EOF ;
+    // InternalRoom.g:876:1: entryRulePort : rulePort EOF ;
     public final void entryRulePort() throws RecognitionException {
         try {
-            // InternalRoom.g:849:1: ( rulePort EOF )
-            // InternalRoom.g:850:1: rulePort EOF
+            // InternalRoom.g:877:1: ( rulePort EOF )
+            // InternalRoom.g:878:1: rulePort EOF
             {
              before(grammarAccess.getPortRule()); 
             pushFollow(FOLLOW_1);
@@ -2373,21 +2450,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rulePort"
-    // InternalRoom.g:857:1: rulePort : ( ( rule__Port__Group__0 ) ) ;
+    // InternalRoom.g:885:1: rulePort : ( ( rule__Port__Group__0 ) ) ;
     public final void rulePort() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:861:2: ( ( ( rule__Port__Group__0 ) ) )
-            // InternalRoom.g:862:1: ( ( rule__Port__Group__0 ) )
+            // InternalRoom.g:889:2: ( ( ( rule__Port__Group__0 ) ) )
+            // InternalRoom.g:890:1: ( ( rule__Port__Group__0 ) )
             {
-            // InternalRoom.g:862:1: ( ( rule__Port__Group__0 ) )
-            // InternalRoom.g:863:1: ( rule__Port__Group__0 )
+            // InternalRoom.g:890:1: ( ( rule__Port__Group__0 ) )
+            // InternalRoom.g:891:1: ( rule__Port__Group__0 )
             {
              before(grammarAccess.getPortAccess().getGroup()); 
-            // InternalRoom.g:864:1: ( rule__Port__Group__0 )
-            // InternalRoom.g:864:2: rule__Port__Group__0
+            // InternalRoom.g:892:1: ( rule__Port__Group__0 )
+            // InternalRoom.g:892:2: rule__Port__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Port__Group__0();
@@ -2420,11 +2497,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleExternalPort"
-    // InternalRoom.g:876:1: entryRuleExternalPort : ruleExternalPort EOF ;
+    // InternalRoom.g:904:1: entryRuleExternalPort : ruleExternalPort EOF ;
     public final void entryRuleExternalPort() throws RecognitionException {
         try {
-            // InternalRoom.g:877:1: ( ruleExternalPort EOF )
-            // InternalRoom.g:878:1: ruleExternalPort EOF
+            // InternalRoom.g:905:1: ( ruleExternalPort EOF )
+            // InternalRoom.g:906:1: ruleExternalPort EOF
             {
              before(grammarAccess.getExternalPortRule()); 
             pushFollow(FOLLOW_1);
@@ -2450,21 +2527,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleExternalPort"
-    // InternalRoom.g:885:1: ruleExternalPort : ( ( rule__ExternalPort__Group__0 ) ) ;
+    // InternalRoom.g:913:1: ruleExternalPort : ( ( rule__ExternalPort__Group__0 ) ) ;
     public final void ruleExternalPort() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:889:2: ( ( ( rule__ExternalPort__Group__0 ) ) )
-            // InternalRoom.g:890:1: ( ( rule__ExternalPort__Group__0 ) )
+            // InternalRoom.g:917:2: ( ( ( rule__ExternalPort__Group__0 ) ) )
+            // InternalRoom.g:918:1: ( ( rule__ExternalPort__Group__0 ) )
             {
-            // InternalRoom.g:890:1: ( ( rule__ExternalPort__Group__0 ) )
-            // InternalRoom.g:891:1: ( rule__ExternalPort__Group__0 )
+            // InternalRoom.g:918:1: ( ( rule__ExternalPort__Group__0 ) )
+            // InternalRoom.g:919:1: ( rule__ExternalPort__Group__0 )
             {
              before(grammarAccess.getExternalPortAccess().getGroup()); 
-            // InternalRoom.g:892:1: ( rule__ExternalPort__Group__0 )
-            // InternalRoom.g:892:2: rule__ExternalPort__Group__0
+            // InternalRoom.g:920:1: ( rule__ExternalPort__Group__0 )
+            // InternalRoom.g:920:2: rule__ExternalPort__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ExternalPort__Group__0();
@@ -2497,11 +2574,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSAP"
-    // InternalRoom.g:904:1: entryRuleSAP : ruleSAP EOF ;
+    // InternalRoom.g:932:1: entryRuleSAP : ruleSAP EOF ;
     public final void entryRuleSAP() throws RecognitionException {
         try {
-            // InternalRoom.g:905:1: ( ruleSAP EOF )
-            // InternalRoom.g:906:1: ruleSAP EOF
+            // InternalRoom.g:933:1: ( ruleSAP EOF )
+            // InternalRoom.g:934:1: ruleSAP EOF
             {
              before(grammarAccess.getSAPRule()); 
             pushFollow(FOLLOW_1);
@@ -2527,21 +2604,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSAP"
-    // InternalRoom.g:913:1: ruleSAP : ( ( rule__SAP__Group__0 ) ) ;
+    // InternalRoom.g:941:1: ruleSAP : ( ( rule__SAP__Group__0 ) ) ;
     public final void ruleSAP() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:917:2: ( ( ( rule__SAP__Group__0 ) ) )
-            // InternalRoom.g:918:1: ( ( rule__SAP__Group__0 ) )
+            // InternalRoom.g:945:2: ( ( ( rule__SAP__Group__0 ) ) )
+            // InternalRoom.g:946:1: ( ( rule__SAP__Group__0 ) )
             {
-            // InternalRoom.g:918:1: ( ( rule__SAP__Group__0 ) )
-            // InternalRoom.g:919:1: ( rule__SAP__Group__0 )
+            // InternalRoom.g:946:1: ( ( rule__SAP__Group__0 ) )
+            // InternalRoom.g:947:1: ( rule__SAP__Group__0 )
             {
              before(grammarAccess.getSAPAccess().getGroup()); 
-            // InternalRoom.g:920:1: ( rule__SAP__Group__0 )
-            // InternalRoom.g:920:2: rule__SAP__Group__0
+            // InternalRoom.g:948:1: ( rule__SAP__Group__0 )
+            // InternalRoom.g:948:2: rule__SAP__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SAP__Group__0();
@@ -2574,11 +2651,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSPP"
-    // InternalRoom.g:932:1: entryRuleSPP : ruleSPP EOF ;
+    // InternalRoom.g:960:1: entryRuleSPP : ruleSPP EOF ;
     public final void entryRuleSPP() throws RecognitionException {
         try {
-            // InternalRoom.g:933:1: ( ruleSPP EOF )
-            // InternalRoom.g:934:1: ruleSPP EOF
+            // InternalRoom.g:961:1: ( ruleSPP EOF )
+            // InternalRoom.g:962:1: ruleSPP EOF
             {
              before(grammarAccess.getSPPRule()); 
             pushFollow(FOLLOW_1);
@@ -2604,21 +2681,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSPP"
-    // InternalRoom.g:941:1: ruleSPP : ( ( rule__SPP__Group__0 ) ) ;
+    // InternalRoom.g:969:1: ruleSPP : ( ( rule__SPP__Group__0 ) ) ;
     public final void ruleSPP() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:945:2: ( ( ( rule__SPP__Group__0 ) ) )
-            // InternalRoom.g:946:1: ( ( rule__SPP__Group__0 ) )
+            // InternalRoom.g:973:2: ( ( ( rule__SPP__Group__0 ) ) )
+            // InternalRoom.g:974:1: ( ( rule__SPP__Group__0 ) )
             {
-            // InternalRoom.g:946:1: ( ( rule__SPP__Group__0 ) )
-            // InternalRoom.g:947:1: ( rule__SPP__Group__0 )
+            // InternalRoom.g:974:1: ( ( rule__SPP__Group__0 ) )
+            // InternalRoom.g:975:1: ( rule__SPP__Group__0 )
             {
              before(grammarAccess.getSPPAccess().getGroup()); 
-            // InternalRoom.g:948:1: ( rule__SPP__Group__0 )
-            // InternalRoom.g:948:2: rule__SPP__Group__0
+            // InternalRoom.g:976:1: ( rule__SPP__Group__0 )
+            // InternalRoom.g:976:2: rule__SPP__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SPP__Group__0();
@@ -2651,11 +2728,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleServiceImplementation"
-    // InternalRoom.g:960:1: entryRuleServiceImplementation : ruleServiceImplementation EOF ;
+    // InternalRoom.g:988:1: entryRuleServiceImplementation : ruleServiceImplementation EOF ;
     public final void entryRuleServiceImplementation() throws RecognitionException {
         try {
-            // InternalRoom.g:961:1: ( ruleServiceImplementation EOF )
-            // InternalRoom.g:962:1: ruleServiceImplementation EOF
+            // InternalRoom.g:989:1: ( ruleServiceImplementation EOF )
+            // InternalRoom.g:990:1: ruleServiceImplementation EOF
             {
              before(grammarAccess.getServiceImplementationRule()); 
             pushFollow(FOLLOW_1);
@@ -2681,21 +2758,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleServiceImplementation"
-    // InternalRoom.g:969:1: ruleServiceImplementation : ( ( rule__ServiceImplementation__Group__0 ) ) ;
+    // InternalRoom.g:997:1: ruleServiceImplementation : ( ( rule__ServiceImplementation__Group__0 ) ) ;
     public final void ruleServiceImplementation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:973:2: ( ( ( rule__ServiceImplementation__Group__0 ) ) )
-            // InternalRoom.g:974:1: ( ( rule__ServiceImplementation__Group__0 ) )
+            // InternalRoom.g:1001:2: ( ( ( rule__ServiceImplementation__Group__0 ) ) )
+            // InternalRoom.g:1002:1: ( ( rule__ServiceImplementation__Group__0 ) )
             {
-            // InternalRoom.g:974:1: ( ( rule__ServiceImplementation__Group__0 ) )
-            // InternalRoom.g:975:1: ( rule__ServiceImplementation__Group__0 )
+            // InternalRoom.g:1002:1: ( ( rule__ServiceImplementation__Group__0 ) )
+            // InternalRoom.g:1003:1: ( rule__ServiceImplementation__Group__0 )
             {
              before(grammarAccess.getServiceImplementationAccess().getGroup()); 
-            // InternalRoom.g:976:1: ( rule__ServiceImplementation__Group__0 )
-            // InternalRoom.g:976:2: rule__ServiceImplementation__Group__0
+            // InternalRoom.g:1004:1: ( rule__ServiceImplementation__Group__0 )
+            // InternalRoom.g:1004:2: rule__ServiceImplementation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ServiceImplementation__Group__0();
@@ -2728,11 +2805,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLogicalSystem"
-    // InternalRoom.g:988:1: entryRuleLogicalSystem : ruleLogicalSystem EOF ;
+    // InternalRoom.g:1016:1: entryRuleLogicalSystem : ruleLogicalSystem EOF ;
     public final void entryRuleLogicalSystem() throws RecognitionException {
         try {
-            // InternalRoom.g:989:1: ( ruleLogicalSystem EOF )
-            // InternalRoom.g:990:1: ruleLogicalSystem EOF
+            // InternalRoom.g:1017:1: ( ruleLogicalSystem EOF )
+            // InternalRoom.g:1018:1: ruleLogicalSystem EOF
             {
              before(grammarAccess.getLogicalSystemRule()); 
             pushFollow(FOLLOW_1);
@@ -2758,21 +2835,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLogicalSystem"
-    // InternalRoom.g:997:1: ruleLogicalSystem : ( ( rule__LogicalSystem__Group__0 ) ) ;
+    // InternalRoom.g:1025:1: ruleLogicalSystem : ( ( rule__LogicalSystem__Group__0 ) ) ;
     public final void ruleLogicalSystem() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1001:2: ( ( ( rule__LogicalSystem__Group__0 ) ) )
-            // InternalRoom.g:1002:1: ( ( rule__LogicalSystem__Group__0 ) )
+            // InternalRoom.g:1029:2: ( ( ( rule__LogicalSystem__Group__0 ) ) )
+            // InternalRoom.g:1030:1: ( ( rule__LogicalSystem__Group__0 ) )
             {
-            // InternalRoom.g:1002:1: ( ( rule__LogicalSystem__Group__0 ) )
-            // InternalRoom.g:1003:1: ( rule__LogicalSystem__Group__0 )
+            // InternalRoom.g:1030:1: ( ( rule__LogicalSystem__Group__0 ) )
+            // InternalRoom.g:1031:1: ( rule__LogicalSystem__Group__0 )
             {
              before(grammarAccess.getLogicalSystemAccess().getGroup()); 
-            // InternalRoom.g:1004:1: ( rule__LogicalSystem__Group__0 )
-            // InternalRoom.g:1004:2: rule__LogicalSystem__Group__0
+            // InternalRoom.g:1032:1: ( rule__LogicalSystem__Group__0 )
+            // InternalRoom.g:1032:2: rule__LogicalSystem__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__LogicalSystem__Group__0();
@@ -2805,11 +2882,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubSystemRef"
-    // InternalRoom.g:1018:1: entryRuleSubSystemRef : ruleSubSystemRef EOF ;
+    // InternalRoom.g:1046:1: entryRuleSubSystemRef : ruleSubSystemRef EOF ;
     public final void entryRuleSubSystemRef() throws RecognitionException {
         try {
-            // InternalRoom.g:1019:1: ( ruleSubSystemRef EOF )
-            // InternalRoom.g:1020:1: ruleSubSystemRef EOF
+            // InternalRoom.g:1047:1: ( ruleSubSystemRef EOF )
+            // InternalRoom.g:1048:1: ruleSubSystemRef EOF
             {
              before(grammarAccess.getSubSystemRefRule()); 
             pushFollow(FOLLOW_1);
@@ -2835,21 +2912,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubSystemRef"
-    // InternalRoom.g:1027:1: ruleSubSystemRef : ( ( rule__SubSystemRef__Group__0 ) ) ;
+    // InternalRoom.g:1055:1: ruleSubSystemRef : ( ( rule__SubSystemRef__Group__0 ) ) ;
     public final void ruleSubSystemRef() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1031:2: ( ( ( rule__SubSystemRef__Group__0 ) ) )
-            // InternalRoom.g:1032:1: ( ( rule__SubSystemRef__Group__0 ) )
+            // InternalRoom.g:1059:2: ( ( ( rule__SubSystemRef__Group__0 ) ) )
+            // InternalRoom.g:1060:1: ( ( rule__SubSystemRef__Group__0 ) )
             {
-            // InternalRoom.g:1032:1: ( ( rule__SubSystemRef__Group__0 ) )
-            // InternalRoom.g:1033:1: ( rule__SubSystemRef__Group__0 )
+            // InternalRoom.g:1060:1: ( ( rule__SubSystemRef__Group__0 ) )
+            // InternalRoom.g:1061:1: ( rule__SubSystemRef__Group__0 )
             {
              before(grammarAccess.getSubSystemRefAccess().getGroup()); 
-            // InternalRoom.g:1034:1: ( rule__SubSystemRef__Group__0 )
-            // InternalRoom.g:1034:2: rule__SubSystemRef__Group__0
+            // InternalRoom.g:1062:1: ( rule__SubSystemRef__Group__0 )
+            // InternalRoom.g:1062:2: rule__SubSystemRef__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__Group__0();
@@ -2882,11 +2959,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubSystemClass"
-    // InternalRoom.g:1046:1: entryRuleSubSystemClass : ruleSubSystemClass EOF ;
+    // InternalRoom.g:1074:1: entryRuleSubSystemClass : ruleSubSystemClass EOF ;
     public final void entryRuleSubSystemClass() throws RecognitionException {
         try {
-            // InternalRoom.g:1047:1: ( ruleSubSystemClass EOF )
-            // InternalRoom.g:1048:1: ruleSubSystemClass EOF
+            // InternalRoom.g:1075:1: ( ruleSubSystemClass EOF )
+            // InternalRoom.g:1076:1: ruleSubSystemClass EOF
             {
              before(grammarAccess.getSubSystemClassRule()); 
             pushFollow(FOLLOW_1);
@@ -2912,21 +2989,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubSystemClass"
-    // InternalRoom.g:1055:1: ruleSubSystemClass : ( ( rule__SubSystemClass__Group__0 ) ) ;
+    // InternalRoom.g:1083:1: ruleSubSystemClass : ( ( rule__SubSystemClass__Group__0 ) ) ;
     public final void ruleSubSystemClass() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1059:2: ( ( ( rule__SubSystemClass__Group__0 ) ) )
-            // InternalRoom.g:1060:1: ( ( rule__SubSystemClass__Group__0 ) )
+            // InternalRoom.g:1087:2: ( ( ( rule__SubSystemClass__Group__0 ) ) )
+            // InternalRoom.g:1088:1: ( ( rule__SubSystemClass__Group__0 ) )
             {
-            // InternalRoom.g:1060:1: ( ( rule__SubSystemClass__Group__0 ) )
-            // InternalRoom.g:1061:1: ( rule__SubSystemClass__Group__0 )
+            // InternalRoom.g:1088:1: ( ( rule__SubSystemClass__Group__0 ) )
+            // InternalRoom.g:1089:1: ( rule__SubSystemClass__Group__0 )
             {
              before(grammarAccess.getSubSystemClassAccess().getGroup()); 
-            // InternalRoom.g:1062:1: ( rule__SubSystemClass__Group__0 )
-            // InternalRoom.g:1062:2: rule__SubSystemClass__Group__0
+            // InternalRoom.g:1090:1: ( rule__SubSystemClass__Group__0 )
+            // InternalRoom.g:1090:2: rule__SubSystemClass__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group__0();
@@ -2959,11 +3036,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLogicalThread"
-    // InternalRoom.g:1074:1: entryRuleLogicalThread : ruleLogicalThread EOF ;
+    // InternalRoom.g:1102:1: entryRuleLogicalThread : ruleLogicalThread EOF ;
     public final void entryRuleLogicalThread() throws RecognitionException {
         try {
-            // InternalRoom.g:1075:1: ( ruleLogicalThread EOF )
-            // InternalRoom.g:1076:1: ruleLogicalThread EOF
+            // InternalRoom.g:1103:1: ( ruleLogicalThread EOF )
+            // InternalRoom.g:1104:1: ruleLogicalThread EOF
             {
              before(grammarAccess.getLogicalThreadRule()); 
             pushFollow(FOLLOW_1);
@@ -2989,21 +3066,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLogicalThread"
-    // InternalRoom.g:1083:1: ruleLogicalThread : ( ( rule__LogicalThread__Group__0 ) ) ;
+    // InternalRoom.g:1111:1: ruleLogicalThread : ( ( rule__LogicalThread__Group__0 ) ) ;
     public final void ruleLogicalThread() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1087:2: ( ( ( rule__LogicalThread__Group__0 ) ) )
-            // InternalRoom.g:1088:1: ( ( rule__LogicalThread__Group__0 ) )
+            // InternalRoom.g:1115:2: ( ( ( rule__LogicalThread__Group__0 ) ) )
+            // InternalRoom.g:1116:1: ( ( rule__LogicalThread__Group__0 ) )
             {
-            // InternalRoom.g:1088:1: ( ( rule__LogicalThread__Group__0 ) )
-            // InternalRoom.g:1089:1: ( rule__LogicalThread__Group__0 )
+            // InternalRoom.g:1116:1: ( ( rule__LogicalThread__Group__0 ) )
+            // InternalRoom.g:1117:1: ( rule__LogicalThread__Group__0 )
             {
              before(grammarAccess.getLogicalThreadAccess().getGroup()); 
-            // InternalRoom.g:1090:1: ( rule__LogicalThread__Group__0 )
-            // InternalRoom.g:1090:2: rule__LogicalThread__Group__0
+            // InternalRoom.g:1118:1: ( rule__LogicalThread__Group__0 )
+            // InternalRoom.g:1118:2: rule__LogicalThread__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__LogicalThread__Group__0();
@@ -3036,11 +3113,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleActorInstanceMapping"
-    // InternalRoom.g:1102:1: entryRuleActorInstanceMapping : ruleActorInstanceMapping EOF ;
+    // InternalRoom.g:1130:1: entryRuleActorInstanceMapping : ruleActorInstanceMapping EOF ;
     public final void entryRuleActorInstanceMapping() throws RecognitionException {
         try {
-            // InternalRoom.g:1103:1: ( ruleActorInstanceMapping EOF )
-            // InternalRoom.g:1104:1: ruleActorInstanceMapping EOF
+            // InternalRoom.g:1131:1: ( ruleActorInstanceMapping EOF )
+            // InternalRoom.g:1132:1: ruleActorInstanceMapping EOF
             {
              before(grammarAccess.getActorInstanceMappingRule()); 
             pushFollow(FOLLOW_1);
@@ -3066,21 +3143,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleActorInstanceMapping"
-    // InternalRoom.g:1111:1: ruleActorInstanceMapping : ( ( rule__ActorInstanceMapping__Group__0 ) ) ;
+    // InternalRoom.g:1139:1: ruleActorInstanceMapping : ( ( rule__ActorInstanceMapping__Group__0 ) ) ;
     public final void ruleActorInstanceMapping() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1115:2: ( ( ( rule__ActorInstanceMapping__Group__0 ) ) )
-            // InternalRoom.g:1116:1: ( ( rule__ActorInstanceMapping__Group__0 ) )
+            // InternalRoom.g:1143:2: ( ( ( rule__ActorInstanceMapping__Group__0 ) ) )
+            // InternalRoom.g:1144:1: ( ( rule__ActorInstanceMapping__Group__0 ) )
             {
-            // InternalRoom.g:1116:1: ( ( rule__ActorInstanceMapping__Group__0 ) )
-            // InternalRoom.g:1117:1: ( rule__ActorInstanceMapping__Group__0 )
+            // InternalRoom.g:1144:1: ( ( rule__ActorInstanceMapping__Group__0 ) )
+            // InternalRoom.g:1145:1: ( rule__ActorInstanceMapping__Group__0 )
             {
              before(grammarAccess.getActorInstanceMappingAccess().getGroup()); 
-            // InternalRoom.g:1118:1: ( rule__ActorInstanceMapping__Group__0 )
-            // InternalRoom.g:1118:2: rule__ActorInstanceMapping__Group__0
+            // InternalRoom.g:1146:1: ( rule__ActorInstanceMapping__Group__0 )
+            // InternalRoom.g:1146:2: rule__ActorInstanceMapping__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__Group__0();
@@ -3113,11 +3190,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefPath"
-    // InternalRoom.g:1130:1: entryRuleRefPath : ruleRefPath EOF ;
+    // InternalRoom.g:1158:1: entryRuleRefPath : ruleRefPath EOF ;
     public final void entryRuleRefPath() throws RecognitionException {
         try {
-            // InternalRoom.g:1131:1: ( ruleRefPath EOF )
-            // InternalRoom.g:1132:1: ruleRefPath EOF
+            // InternalRoom.g:1159:1: ( ruleRefPath EOF )
+            // InternalRoom.g:1160:1: ruleRefPath EOF
             {
              before(grammarAccess.getRefPathRule()); 
             pushFollow(FOLLOW_1);
@@ -3143,21 +3220,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefPath"
-    // InternalRoom.g:1139:1: ruleRefPath : ( ( rule__RefPath__Group__0 ) ) ;
+    // InternalRoom.g:1167:1: ruleRefPath : ( ( rule__RefPath__Group__0 ) ) ;
     public final void ruleRefPath() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1143:2: ( ( ( rule__RefPath__Group__0 ) ) )
-            // InternalRoom.g:1144:1: ( ( rule__RefPath__Group__0 ) )
+            // InternalRoom.g:1171:2: ( ( ( rule__RefPath__Group__0 ) ) )
+            // InternalRoom.g:1172:1: ( ( rule__RefPath__Group__0 ) )
             {
-            // InternalRoom.g:1144:1: ( ( rule__RefPath__Group__0 ) )
-            // InternalRoom.g:1145:1: ( rule__RefPath__Group__0 )
+            // InternalRoom.g:1172:1: ( ( rule__RefPath__Group__0 ) )
+            // InternalRoom.g:1173:1: ( rule__RefPath__Group__0 )
             {
              before(grammarAccess.getRefPathAccess().getGroup()); 
-            // InternalRoom.g:1146:1: ( rule__RefPath__Group__0 )
-            // InternalRoom.g:1146:2: rule__RefPath__Group__0
+            // InternalRoom.g:1174:1: ( rule__RefPath__Group__0 )
+            // InternalRoom.g:1174:2: rule__RefPath__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__Group__0();
@@ -3190,11 +3267,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefSegment"
-    // InternalRoom.g:1158:1: entryRuleRefSegment : ruleRefSegment EOF ;
+    // InternalRoom.g:1186:1: entryRuleRefSegment : ruleRefSegment EOF ;
     public final void entryRuleRefSegment() throws RecognitionException {
         try {
-            // InternalRoom.g:1159:1: ( ruleRefSegment EOF )
-            // InternalRoom.g:1160:1: ruleRefSegment EOF
+            // InternalRoom.g:1187:1: ( ruleRefSegment EOF )
+            // InternalRoom.g:1188:1: ruleRefSegment EOF
             {
              before(grammarAccess.getRefSegmentRule()); 
             pushFollow(FOLLOW_1);
@@ -3220,21 +3297,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefSegment"
-    // InternalRoom.g:1167:1: ruleRefSegment : ( ( rule__RefSegment__Group__0 ) ) ;
+    // InternalRoom.g:1195:1: ruleRefSegment : ( ( rule__RefSegment__Group__0 ) ) ;
     public final void ruleRefSegment() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1171:2: ( ( ( rule__RefSegment__Group__0 ) ) )
-            // InternalRoom.g:1172:1: ( ( rule__RefSegment__Group__0 ) )
+            // InternalRoom.g:1199:2: ( ( ( rule__RefSegment__Group__0 ) ) )
+            // InternalRoom.g:1200:1: ( ( rule__RefSegment__Group__0 ) )
             {
-            // InternalRoom.g:1172:1: ( ( rule__RefSegment__Group__0 ) )
-            // InternalRoom.g:1173:1: ( rule__RefSegment__Group__0 )
+            // InternalRoom.g:1200:1: ( ( rule__RefSegment__Group__0 ) )
+            // InternalRoom.g:1201:1: ( rule__RefSegment__Group__0 )
             {
              before(grammarAccess.getRefSegmentAccess().getGroup()); 
-            // InternalRoom.g:1174:1: ( rule__RefSegment__Group__0 )
-            // InternalRoom.g:1174:2: rule__RefSegment__Group__0
+            // InternalRoom.g:1202:1: ( rule__RefSegment__Group__0 )
+            // InternalRoom.g:1202:2: rule__RefSegment__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__Group__0();
@@ -3267,11 +3344,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleBinding"
-    // InternalRoom.g:1186:1: entryRuleBinding : ruleBinding EOF ;
+    // InternalRoom.g:1214:1: entryRuleBinding : ruleBinding EOF ;
     public final void entryRuleBinding() throws RecognitionException {
         try {
-            // InternalRoom.g:1187:1: ( ruleBinding EOF )
-            // InternalRoom.g:1188:1: ruleBinding EOF
+            // InternalRoom.g:1215:1: ( ruleBinding EOF )
+            // InternalRoom.g:1216:1: ruleBinding EOF
             {
              before(grammarAccess.getBindingRule()); 
             pushFollow(FOLLOW_1);
@@ -3297,21 +3374,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleBinding"
-    // InternalRoom.g:1195:1: ruleBinding : ( ( rule__Binding__Group__0 ) ) ;
+    // InternalRoom.g:1223:1: ruleBinding : ( ( rule__Binding__Group__0 ) ) ;
     public final void ruleBinding() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1199:2: ( ( ( rule__Binding__Group__0 ) ) )
-            // InternalRoom.g:1200:1: ( ( rule__Binding__Group__0 ) )
+            // InternalRoom.g:1227:2: ( ( ( rule__Binding__Group__0 ) ) )
+            // InternalRoom.g:1228:1: ( ( rule__Binding__Group__0 ) )
             {
-            // InternalRoom.g:1200:1: ( ( rule__Binding__Group__0 ) )
-            // InternalRoom.g:1201:1: ( rule__Binding__Group__0 )
+            // InternalRoom.g:1228:1: ( ( rule__Binding__Group__0 ) )
+            // InternalRoom.g:1229:1: ( rule__Binding__Group__0 )
             {
              before(grammarAccess.getBindingAccess().getGroup()); 
-            // InternalRoom.g:1202:1: ( rule__Binding__Group__0 )
-            // InternalRoom.g:1202:2: rule__Binding__Group__0
+            // InternalRoom.g:1230:1: ( rule__Binding__Group__0 )
+            // InternalRoom.g:1230:2: rule__Binding__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Group__0();
@@ -3344,11 +3421,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleBindingEndPoint"
-    // InternalRoom.g:1214:1: entryRuleBindingEndPoint : ruleBindingEndPoint EOF ;
+    // InternalRoom.g:1242:1: entryRuleBindingEndPoint : ruleBindingEndPoint EOF ;
     public final void entryRuleBindingEndPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1215:1: ( ruleBindingEndPoint EOF )
-            // InternalRoom.g:1216:1: ruleBindingEndPoint EOF
+            // InternalRoom.g:1243:1: ( ruleBindingEndPoint EOF )
+            // InternalRoom.g:1244:1: ruleBindingEndPoint EOF
             {
              before(grammarAccess.getBindingEndPointRule()); 
             pushFollow(FOLLOW_1);
@@ -3374,21 +3451,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleBindingEndPoint"
-    // InternalRoom.g:1223:1: ruleBindingEndPoint : ( ( rule__BindingEndPoint__Group__0 ) ) ;
+    // InternalRoom.g:1251:1: ruleBindingEndPoint : ( ( rule__BindingEndPoint__Group__0 ) ) ;
     public final void ruleBindingEndPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1227:2: ( ( ( rule__BindingEndPoint__Group__0 ) ) )
-            // InternalRoom.g:1228:1: ( ( rule__BindingEndPoint__Group__0 ) )
+            // InternalRoom.g:1255:2: ( ( ( rule__BindingEndPoint__Group__0 ) ) )
+            // InternalRoom.g:1256:1: ( ( rule__BindingEndPoint__Group__0 ) )
             {
-            // InternalRoom.g:1228:1: ( ( rule__BindingEndPoint__Group__0 ) )
-            // InternalRoom.g:1229:1: ( rule__BindingEndPoint__Group__0 )
+            // InternalRoom.g:1256:1: ( ( rule__BindingEndPoint__Group__0 ) )
+            // InternalRoom.g:1257:1: ( rule__BindingEndPoint__Group__0 )
             {
              before(grammarAccess.getBindingEndPointAccess().getGroup()); 
-            // InternalRoom.g:1230:1: ( rule__BindingEndPoint__Group__0 )
-            // InternalRoom.g:1230:2: rule__BindingEndPoint__Group__0
+            // InternalRoom.g:1258:1: ( rule__BindingEndPoint__Group__0 )
+            // InternalRoom.g:1258:2: rule__BindingEndPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group__0();
@@ -3421,11 +3498,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLayerConnection"
-    // InternalRoom.g:1242:1: entryRuleLayerConnection : ruleLayerConnection EOF ;
+    // InternalRoom.g:1270:1: entryRuleLayerConnection : ruleLayerConnection EOF ;
     public final void entryRuleLayerConnection() throws RecognitionException {
         try {
-            // InternalRoom.g:1243:1: ( ruleLayerConnection EOF )
-            // InternalRoom.g:1244:1: ruleLayerConnection EOF
+            // InternalRoom.g:1271:1: ( ruleLayerConnection EOF )
+            // InternalRoom.g:1272:1: ruleLayerConnection EOF
             {
              before(grammarAccess.getLayerConnectionRule()); 
             pushFollow(FOLLOW_1);
@@ -3451,21 +3528,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLayerConnection"
-    // InternalRoom.g:1251:1: ruleLayerConnection : ( ( rule__LayerConnection__Group__0 ) ) ;
+    // InternalRoom.g:1279:1: ruleLayerConnection : ( ( rule__LayerConnection__Group__0 ) ) ;
     public final void ruleLayerConnection() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1255:2: ( ( ( rule__LayerConnection__Group__0 ) ) )
-            // InternalRoom.g:1256:1: ( ( rule__LayerConnection__Group__0 ) )
+            // InternalRoom.g:1283:2: ( ( ( rule__LayerConnection__Group__0 ) ) )
+            // InternalRoom.g:1284:1: ( ( rule__LayerConnection__Group__0 ) )
             {
-            // InternalRoom.g:1256:1: ( ( rule__LayerConnection__Group__0 ) )
-            // InternalRoom.g:1257:1: ( rule__LayerConnection__Group__0 )
+            // InternalRoom.g:1284:1: ( ( rule__LayerConnection__Group__0 ) )
+            // InternalRoom.g:1285:1: ( rule__LayerConnection__Group__0 )
             {
              before(grammarAccess.getLayerConnectionAccess().getGroup()); 
-            // InternalRoom.g:1258:1: ( rule__LayerConnection__Group__0 )
-            // InternalRoom.g:1258:2: rule__LayerConnection__Group__0
+            // InternalRoom.g:1286:1: ( rule__LayerConnection__Group__0 )
+            // InternalRoom.g:1286:2: rule__LayerConnection__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__Group__0();
@@ -3498,11 +3575,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSAPoint"
-    // InternalRoom.g:1270:1: entryRuleSAPoint : ruleSAPoint EOF ;
+    // InternalRoom.g:1298:1: entryRuleSAPoint : ruleSAPoint EOF ;
     public final void entryRuleSAPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1271:1: ( ruleSAPoint EOF )
-            // InternalRoom.g:1272:1: ruleSAPoint EOF
+            // InternalRoom.g:1299:1: ( ruleSAPoint EOF )
+            // InternalRoom.g:1300:1: ruleSAPoint EOF
             {
              before(grammarAccess.getSAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -3528,21 +3605,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSAPoint"
-    // InternalRoom.g:1279:1: ruleSAPoint : ( ( rule__SAPoint__Alternatives ) ) ;
+    // InternalRoom.g:1307:1: ruleSAPoint : ( ( rule__SAPoint__Alternatives ) ) ;
     public final void ruleSAPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1283:2: ( ( ( rule__SAPoint__Alternatives ) ) )
-            // InternalRoom.g:1284:1: ( ( rule__SAPoint__Alternatives ) )
+            // InternalRoom.g:1311:2: ( ( ( rule__SAPoint__Alternatives ) ) )
+            // InternalRoom.g:1312:1: ( ( rule__SAPoint__Alternatives ) )
             {
-            // InternalRoom.g:1284:1: ( ( rule__SAPoint__Alternatives ) )
-            // InternalRoom.g:1285:1: ( rule__SAPoint__Alternatives )
+            // InternalRoom.g:1312:1: ( ( rule__SAPoint__Alternatives ) )
+            // InternalRoom.g:1313:1: ( rule__SAPoint__Alternatives )
             {
              before(grammarAccess.getSAPointAccess().getAlternatives()); 
-            // InternalRoom.g:1286:1: ( rule__SAPoint__Alternatives )
-            // InternalRoom.g:1286:2: rule__SAPoint__Alternatives
+            // InternalRoom.g:1314:1: ( rule__SAPoint__Alternatives )
+            // InternalRoom.g:1314:2: rule__SAPoint__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__SAPoint__Alternatives();
@@ -3575,11 +3652,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefSAPoint"
-    // InternalRoom.g:1298:1: entryRuleRefSAPoint : ruleRefSAPoint EOF ;
+    // InternalRoom.g:1326:1: entryRuleRefSAPoint : ruleRefSAPoint EOF ;
     public final void entryRuleRefSAPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1299:1: ( ruleRefSAPoint EOF )
-            // InternalRoom.g:1300:1: ruleRefSAPoint EOF
+            // InternalRoom.g:1327:1: ( ruleRefSAPoint EOF )
+            // InternalRoom.g:1328:1: ruleRefSAPoint EOF
             {
              before(grammarAccess.getRefSAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -3605,21 +3682,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefSAPoint"
-    // InternalRoom.g:1307:1: ruleRefSAPoint : ( ( rule__RefSAPoint__Group__0 ) ) ;
+    // InternalRoom.g:1335:1: ruleRefSAPoint : ( ( rule__RefSAPoint__Group__0 ) ) ;
     public final void ruleRefSAPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1311:2: ( ( ( rule__RefSAPoint__Group__0 ) ) )
-            // InternalRoom.g:1312:1: ( ( rule__RefSAPoint__Group__0 ) )
+            // InternalRoom.g:1339:2: ( ( ( rule__RefSAPoint__Group__0 ) ) )
+            // InternalRoom.g:1340:1: ( ( rule__RefSAPoint__Group__0 ) )
             {
-            // InternalRoom.g:1312:1: ( ( rule__RefSAPoint__Group__0 ) )
-            // InternalRoom.g:1313:1: ( rule__RefSAPoint__Group__0 )
+            // InternalRoom.g:1340:1: ( ( rule__RefSAPoint__Group__0 ) )
+            // InternalRoom.g:1341:1: ( rule__RefSAPoint__Group__0 )
             {
              before(grammarAccess.getRefSAPointAccess().getGroup()); 
-            // InternalRoom.g:1314:1: ( rule__RefSAPoint__Group__0 )
-            // InternalRoom.g:1314:2: rule__RefSAPoint__Group__0
+            // InternalRoom.g:1342:1: ( rule__RefSAPoint__Group__0 )
+            // InternalRoom.g:1342:2: rule__RefSAPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefSAPoint__Group__0();
@@ -3652,11 +3729,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRelaySAPoint"
-    // InternalRoom.g:1326:1: entryRuleRelaySAPoint : ruleRelaySAPoint EOF ;
+    // InternalRoom.g:1354:1: entryRuleRelaySAPoint : ruleRelaySAPoint EOF ;
     public final void entryRuleRelaySAPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1327:1: ( ruleRelaySAPoint EOF )
-            // InternalRoom.g:1328:1: ruleRelaySAPoint EOF
+            // InternalRoom.g:1355:1: ( ruleRelaySAPoint EOF )
+            // InternalRoom.g:1356:1: ruleRelaySAPoint EOF
             {
              before(grammarAccess.getRelaySAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -3682,21 +3759,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRelaySAPoint"
-    // InternalRoom.g:1335:1: ruleRelaySAPoint : ( ( rule__RelaySAPoint__Group__0 ) ) ;
+    // InternalRoom.g:1363:1: ruleRelaySAPoint : ( ( rule__RelaySAPoint__Group__0 ) ) ;
     public final void ruleRelaySAPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1339:2: ( ( ( rule__RelaySAPoint__Group__0 ) ) )
-            // InternalRoom.g:1340:1: ( ( rule__RelaySAPoint__Group__0 ) )
+            // InternalRoom.g:1367:2: ( ( ( rule__RelaySAPoint__Group__0 ) ) )
+            // InternalRoom.g:1368:1: ( ( rule__RelaySAPoint__Group__0 ) )
             {
-            // InternalRoom.g:1340:1: ( ( rule__RelaySAPoint__Group__0 ) )
-            // InternalRoom.g:1341:1: ( rule__RelaySAPoint__Group__0 )
+            // InternalRoom.g:1368:1: ( ( rule__RelaySAPoint__Group__0 ) )
+            // InternalRoom.g:1369:1: ( rule__RelaySAPoint__Group__0 )
             {
              before(grammarAccess.getRelaySAPointAccess().getGroup()); 
-            // InternalRoom.g:1342:1: ( rule__RelaySAPoint__Group__0 )
-            // InternalRoom.g:1342:2: rule__RelaySAPoint__Group__0
+            // InternalRoom.g:1370:1: ( rule__RelaySAPoint__Group__0 )
+            // InternalRoom.g:1370:2: rule__RelaySAPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RelaySAPoint__Group__0();
@@ -3729,11 +3806,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSPPoint"
-    // InternalRoom.g:1354:1: entryRuleSPPoint : ruleSPPoint EOF ;
+    // InternalRoom.g:1382:1: entryRuleSPPoint : ruleSPPoint EOF ;
     public final void entryRuleSPPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1355:1: ( ruleSPPoint EOF )
-            // InternalRoom.g:1356:1: ruleSPPoint EOF
+            // InternalRoom.g:1383:1: ( ruleSPPoint EOF )
+            // InternalRoom.g:1384:1: ruleSPPoint EOF
             {
              before(grammarAccess.getSPPointRule()); 
             pushFollow(FOLLOW_1);
@@ -3759,21 +3836,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSPPoint"
-    // InternalRoom.g:1363:1: ruleSPPoint : ( ( rule__SPPoint__Group__0 ) ) ;
+    // InternalRoom.g:1391:1: ruleSPPoint : ( ( rule__SPPoint__Group__0 ) ) ;
     public final void ruleSPPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1367:2: ( ( ( rule__SPPoint__Group__0 ) ) )
-            // InternalRoom.g:1368:1: ( ( rule__SPPoint__Group__0 ) )
+            // InternalRoom.g:1395:2: ( ( ( rule__SPPoint__Group__0 ) ) )
+            // InternalRoom.g:1396:1: ( ( rule__SPPoint__Group__0 ) )
             {
-            // InternalRoom.g:1368:1: ( ( rule__SPPoint__Group__0 ) )
-            // InternalRoom.g:1369:1: ( rule__SPPoint__Group__0 )
+            // InternalRoom.g:1396:1: ( ( rule__SPPoint__Group__0 ) )
+            // InternalRoom.g:1397:1: ( rule__SPPoint__Group__0 )
             {
              before(grammarAccess.getSPPointAccess().getGroup()); 
-            // InternalRoom.g:1370:1: ( rule__SPPoint__Group__0 )
-            // InternalRoom.g:1370:2: rule__SPPoint__Group__0
+            // InternalRoom.g:1398:1: ( rule__SPPoint__Group__0 )
+            // InternalRoom.g:1398:2: rule__SPPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__Group__0();
@@ -3806,11 +3883,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleActorRef"
-    // InternalRoom.g:1382:1: entryRuleActorRef : ruleActorRef EOF ;
+    // InternalRoom.g:1410:1: entryRuleActorRef : ruleActorRef EOF ;
     public final void entryRuleActorRef() throws RecognitionException {
         try {
-            // InternalRoom.g:1383:1: ( ruleActorRef EOF )
-            // InternalRoom.g:1384:1: ruleActorRef EOF
+            // InternalRoom.g:1411:1: ( ruleActorRef EOF )
+            // InternalRoom.g:1412:1: ruleActorRef EOF
             {
              before(grammarAccess.getActorRefRule()); 
             pushFollow(FOLLOW_1);
@@ -3836,21 +3913,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleActorRef"
-    // InternalRoom.g:1391:1: ruleActorRef : ( ( rule__ActorRef__Group__0 ) ) ;
+    // InternalRoom.g:1419:1: ruleActorRef : ( ( rule__ActorRef__Group__0 ) ) ;
     public final void ruleActorRef() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1395:2: ( ( ( rule__ActorRef__Group__0 ) ) )
-            // InternalRoom.g:1396:1: ( ( rule__ActorRef__Group__0 ) )
+            // InternalRoom.g:1423:2: ( ( ( rule__ActorRef__Group__0 ) ) )
+            // InternalRoom.g:1424:1: ( ( rule__ActorRef__Group__0 ) )
             {
-            // InternalRoom.g:1396:1: ( ( rule__ActorRef__Group__0 ) )
-            // InternalRoom.g:1397:1: ( rule__ActorRef__Group__0 )
+            // InternalRoom.g:1424:1: ( ( rule__ActorRef__Group__0 ) )
+            // InternalRoom.g:1425:1: ( rule__ActorRef__Group__0 )
             {
              before(grammarAccess.getActorRefAccess().getGroup()); 
-            // InternalRoom.g:1398:1: ( rule__ActorRef__Group__0 )
-            // InternalRoom.g:1398:2: rule__ActorRef__Group__0
+            // InternalRoom.g:1426:1: ( rule__ActorRef__Group__0 )
+            // InternalRoom.g:1426:2: rule__ActorRef__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__Group__0();
@@ -3883,11 +3960,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMULTIPLICITY"
-    // InternalRoom.g:1412:1: entryRuleMULTIPLICITY : ruleMULTIPLICITY EOF ;
+    // InternalRoom.g:1440:1: entryRuleMULTIPLICITY : ruleMULTIPLICITY EOF ;
     public final void entryRuleMULTIPLICITY() throws RecognitionException {
         try {
-            // InternalRoom.g:1413:1: ( ruleMULTIPLICITY EOF )
-            // InternalRoom.g:1414:1: ruleMULTIPLICITY EOF
+            // InternalRoom.g:1441:1: ( ruleMULTIPLICITY EOF )
+            // InternalRoom.g:1442:1: ruleMULTIPLICITY EOF
             {
              before(grammarAccess.getMULTIPLICITYRule()); 
             pushFollow(FOLLOW_1);
@@ -3913,21 +3990,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMULTIPLICITY"
-    // InternalRoom.g:1421:1: ruleMULTIPLICITY : ( ( rule__MULTIPLICITY__Group__0 ) ) ;
+    // InternalRoom.g:1449:1: ruleMULTIPLICITY : ( ( rule__MULTIPLICITY__Group__0 ) ) ;
     public final void ruleMULTIPLICITY() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1425:2: ( ( ( rule__MULTIPLICITY__Group__0 ) ) )
-            // InternalRoom.g:1426:1: ( ( rule__MULTIPLICITY__Group__0 ) )
+            // InternalRoom.g:1453:2: ( ( ( rule__MULTIPLICITY__Group__0 ) ) )
+            // InternalRoom.g:1454:1: ( ( rule__MULTIPLICITY__Group__0 ) )
             {
-            // InternalRoom.g:1426:1: ( ( rule__MULTIPLICITY__Group__0 ) )
-            // InternalRoom.g:1427:1: ( rule__MULTIPLICITY__Group__0 )
+            // InternalRoom.g:1454:1: ( ( rule__MULTIPLICITY__Group__0 ) )
+            // InternalRoom.g:1455:1: ( rule__MULTIPLICITY__Group__0 )
             {
              before(grammarAccess.getMULTIPLICITYAccess().getGroup()); 
-            // InternalRoom.g:1428:1: ( rule__MULTIPLICITY__Group__0 )
-            // InternalRoom.g:1428:2: rule__MULTIPLICITY__Group__0
+            // InternalRoom.g:1456:1: ( rule__MULTIPLICITY__Group__0 )
+            // InternalRoom.g:1456:2: rule__MULTIPLICITY__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__MULTIPLICITY__Group__0();
@@ -3960,11 +4037,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationTargetType"
-    // InternalRoom.g:1440:1: entryRuleAnnotationTargetType : ruleAnnotationTargetType EOF ;
+    // InternalRoom.g:1468:1: entryRuleAnnotationTargetType : ruleAnnotationTargetType EOF ;
     public final void entryRuleAnnotationTargetType() throws RecognitionException {
         try {
-            // InternalRoom.g:1441:1: ( ruleAnnotationTargetType EOF )
-            // InternalRoom.g:1442:1: ruleAnnotationTargetType EOF
+            // InternalRoom.g:1469:1: ( ruleAnnotationTargetType EOF )
+            // InternalRoom.g:1470:1: ruleAnnotationTargetType EOF
             {
              before(grammarAccess.getAnnotationTargetTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -3990,21 +4067,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationTargetType"
-    // InternalRoom.g:1449:1: ruleAnnotationTargetType : ( ( rule__AnnotationTargetType__Alternatives ) ) ;
+    // InternalRoom.g:1477:1: ruleAnnotationTargetType : ( ( rule__AnnotationTargetType__Alternatives ) ) ;
     public final void ruleAnnotationTargetType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1453:2: ( ( ( rule__AnnotationTargetType__Alternatives ) ) )
-            // InternalRoom.g:1454:1: ( ( rule__AnnotationTargetType__Alternatives ) )
+            // InternalRoom.g:1481:2: ( ( ( rule__AnnotationTargetType__Alternatives ) ) )
+            // InternalRoom.g:1482:1: ( ( rule__AnnotationTargetType__Alternatives ) )
             {
-            // InternalRoom.g:1454:1: ( ( rule__AnnotationTargetType__Alternatives ) )
-            // InternalRoom.g:1455:1: ( rule__AnnotationTargetType__Alternatives )
+            // InternalRoom.g:1482:1: ( ( rule__AnnotationTargetType__Alternatives ) )
+            // InternalRoom.g:1483:1: ( rule__AnnotationTargetType__Alternatives )
             {
              before(grammarAccess.getAnnotationTargetTypeAccess().getAlternatives()); 
-            // InternalRoom.g:1456:1: ( rule__AnnotationTargetType__Alternatives )
-            // InternalRoom.g:1456:2: rule__AnnotationTargetType__Alternatives
+            // InternalRoom.g:1484:1: ( rule__AnnotationTargetType__Alternatives )
+            // InternalRoom.g:1484:2: rule__AnnotationTargetType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationTargetType__Alternatives();
@@ -4037,11 +4114,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateGraphNode"
-    // InternalRoom.g:1470:1: entryRuleStateGraphNode : ruleStateGraphNode EOF ;
+    // InternalRoom.g:1498:1: entryRuleStateGraphNode : ruleStateGraphNode EOF ;
     public final void entryRuleStateGraphNode() throws RecognitionException {
         try {
-            // InternalRoom.g:1471:1: ( ruleStateGraphNode EOF )
-            // InternalRoom.g:1472:1: ruleStateGraphNode EOF
+            // InternalRoom.g:1499:1: ( ruleStateGraphNode EOF )
+            // InternalRoom.g:1500:1: ruleStateGraphNode EOF
             {
              before(grammarAccess.getStateGraphNodeRule()); 
             pushFollow(FOLLOW_1);
@@ -4067,21 +4144,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateGraphNode"
-    // InternalRoom.g:1479:1: ruleStateGraphNode : ( ( rule__StateGraphNode__Alternatives ) ) ;
+    // InternalRoom.g:1507:1: ruleStateGraphNode : ( ( rule__StateGraphNode__Alternatives ) ) ;
     public final void ruleStateGraphNode() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1483:2: ( ( ( rule__StateGraphNode__Alternatives ) ) )
-            // InternalRoom.g:1484:1: ( ( rule__StateGraphNode__Alternatives ) )
+            // InternalRoom.g:1511:2: ( ( ( rule__StateGraphNode__Alternatives ) ) )
+            // InternalRoom.g:1512:1: ( ( rule__StateGraphNode__Alternatives ) )
             {
-            // InternalRoom.g:1484:1: ( ( rule__StateGraphNode__Alternatives ) )
-            // InternalRoom.g:1485:1: ( rule__StateGraphNode__Alternatives )
+            // InternalRoom.g:1512:1: ( ( rule__StateGraphNode__Alternatives ) )
+            // InternalRoom.g:1513:1: ( rule__StateGraphNode__Alternatives )
             {
              before(grammarAccess.getStateGraphNodeAccess().getAlternatives()); 
-            // InternalRoom.g:1486:1: ( rule__StateGraphNode__Alternatives )
-            // InternalRoom.g:1486:2: rule__StateGraphNode__Alternatives
+            // InternalRoom.g:1514:1: ( rule__StateGraphNode__Alternatives )
+            // InternalRoom.g:1514:2: rule__StateGraphNode__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__StateGraphNode__Alternatives();
@@ -4114,11 +4191,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateGraph"
-    // InternalRoom.g:1500:1: entryRuleStateGraph : ruleStateGraph EOF ;
+    // InternalRoom.g:1528:1: entryRuleStateGraph : ruleStateGraph EOF ;
     public final void entryRuleStateGraph() throws RecognitionException {
         try {
-            // InternalRoom.g:1501:1: ( ruleStateGraph EOF )
-            // InternalRoom.g:1502:1: ruleStateGraph EOF
+            // InternalRoom.g:1529:1: ( ruleStateGraph EOF )
+            // InternalRoom.g:1530:1: ruleStateGraph EOF
             {
              before(grammarAccess.getStateGraphRule()); 
             pushFollow(FOLLOW_1);
@@ -4144,21 +4221,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateGraph"
-    // InternalRoom.g:1509:1: ruleStateGraph : ( ( rule__StateGraph__Group__0 ) ) ;
+    // InternalRoom.g:1537:1: ruleStateGraph : ( ( rule__StateGraph__Group__0 ) ) ;
     public final void ruleStateGraph() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1513:2: ( ( ( rule__StateGraph__Group__0 ) ) )
-            // InternalRoom.g:1514:1: ( ( rule__StateGraph__Group__0 ) )
+            // InternalRoom.g:1541:2: ( ( ( rule__StateGraph__Group__0 ) ) )
+            // InternalRoom.g:1542:1: ( ( rule__StateGraph__Group__0 ) )
             {
-            // InternalRoom.g:1514:1: ( ( rule__StateGraph__Group__0 ) )
-            // InternalRoom.g:1515:1: ( rule__StateGraph__Group__0 )
+            // InternalRoom.g:1542:1: ( ( rule__StateGraph__Group__0 ) )
+            // InternalRoom.g:1543:1: ( rule__StateGraph__Group__0 )
             {
              before(grammarAccess.getStateGraphAccess().getGroup()); 
-            // InternalRoom.g:1516:1: ( rule__StateGraph__Group__0 )
-            // InternalRoom.g:1516:2: rule__StateGraph__Group__0
+            // InternalRoom.g:1544:1: ( rule__StateGraph__Group__0 )
+            // InternalRoom.g:1544:2: rule__StateGraph__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StateGraph__Group__0();
@@ -4191,11 +4268,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateMachine"
-    // InternalRoom.g:1528:1: entryRuleStateMachine : ruleStateMachine EOF ;
+    // InternalRoom.g:1556:1: entryRuleStateMachine : ruleStateMachine EOF ;
     public final void entryRuleStateMachine() throws RecognitionException {
         try {
-            // InternalRoom.g:1529:1: ( ruleStateMachine EOF )
-            // InternalRoom.g:1530:1: ruleStateMachine EOF
+            // InternalRoom.g:1557:1: ( ruleStateMachine EOF )
+            // InternalRoom.g:1558:1: ruleStateMachine EOF
             {
              before(grammarAccess.getStateMachineRule()); 
             pushFollow(FOLLOW_1);
@@ -4221,21 +4298,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateMachine"
-    // InternalRoom.g:1537:1: ruleStateMachine : ( ( rule__StateMachine__Group__0 ) ) ;
+    // InternalRoom.g:1565:1: ruleStateMachine : ( ( rule__StateMachine__Group__0 ) ) ;
     public final void ruleStateMachine() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1541:2: ( ( ( rule__StateMachine__Group__0 ) ) )
-            // InternalRoom.g:1542:1: ( ( rule__StateMachine__Group__0 ) )
+            // InternalRoom.g:1569:2: ( ( ( rule__StateMachine__Group__0 ) ) )
+            // InternalRoom.g:1570:1: ( ( rule__StateMachine__Group__0 ) )
             {
-            // InternalRoom.g:1542:1: ( ( rule__StateMachine__Group__0 ) )
-            // InternalRoom.g:1543:1: ( rule__StateMachine__Group__0 )
+            // InternalRoom.g:1570:1: ( ( rule__StateMachine__Group__0 ) )
+            // InternalRoom.g:1571:1: ( rule__StateMachine__Group__0 )
             {
              before(grammarAccess.getStateMachineAccess().getGroup()); 
-            // InternalRoom.g:1544:1: ( rule__StateMachine__Group__0 )
-            // InternalRoom.g:1544:2: rule__StateMachine__Group__0
+            // InternalRoom.g:1572:1: ( rule__StateMachine__Group__0 )
+            // InternalRoom.g:1572:2: rule__StateMachine__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StateMachine__Group__0();
@@ -4268,11 +4345,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleState"
-    // InternalRoom.g:1556:1: entryRuleState : ruleState EOF ;
+    // InternalRoom.g:1584:1: entryRuleState : ruleState EOF ;
     public final void entryRuleState() throws RecognitionException {
         try {
-            // InternalRoom.g:1557:1: ( ruleState EOF )
-            // InternalRoom.g:1558:1: ruleState EOF
+            // InternalRoom.g:1585:1: ( ruleState EOF )
+            // InternalRoom.g:1586:1: ruleState EOF
             {
              before(grammarAccess.getStateRule()); 
             pushFollow(FOLLOW_1);
@@ -4298,21 +4375,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleState"
-    // InternalRoom.g:1565:1: ruleState : ( ( rule__State__Alternatives ) ) ;
+    // InternalRoom.g:1593:1: ruleState : ( ( rule__State__Alternatives ) ) ;
     public final void ruleState() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1569:2: ( ( ( rule__State__Alternatives ) ) )
-            // InternalRoom.g:1570:1: ( ( rule__State__Alternatives ) )
+            // InternalRoom.g:1597:2: ( ( ( rule__State__Alternatives ) ) )
+            // InternalRoom.g:1598:1: ( ( rule__State__Alternatives ) )
             {
-            // InternalRoom.g:1570:1: ( ( rule__State__Alternatives ) )
-            // InternalRoom.g:1571:1: ( rule__State__Alternatives )
+            // InternalRoom.g:1598:1: ( ( rule__State__Alternatives ) )
+            // InternalRoom.g:1599:1: ( rule__State__Alternatives )
             {
              before(grammarAccess.getStateAccess().getAlternatives()); 
-            // InternalRoom.g:1572:1: ( rule__State__Alternatives )
-            // InternalRoom.g:1572:2: rule__State__Alternatives
+            // InternalRoom.g:1600:1: ( rule__State__Alternatives )
+            // InternalRoom.g:1600:2: rule__State__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__State__Alternatives();
@@ -4345,11 +4422,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSimpleState"
-    // InternalRoom.g:1584:1: entryRuleSimpleState : ruleSimpleState EOF ;
+    // InternalRoom.g:1612:1: entryRuleSimpleState : ruleSimpleState EOF ;
     public final void entryRuleSimpleState() throws RecognitionException {
         try {
-            // InternalRoom.g:1585:1: ( ruleSimpleState EOF )
-            // InternalRoom.g:1586:1: ruleSimpleState EOF
+            // InternalRoom.g:1613:1: ( ruleSimpleState EOF )
+            // InternalRoom.g:1614:1: ruleSimpleState EOF
             {
              before(grammarAccess.getSimpleStateRule()); 
             pushFollow(FOLLOW_1);
@@ -4375,21 +4452,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSimpleState"
-    // InternalRoom.g:1593:1: ruleSimpleState : ( ( rule__SimpleState__Group__0 ) ) ;
+    // InternalRoom.g:1621:1: ruleSimpleState : ( ( rule__SimpleState__Group__0 ) ) ;
     public final void ruleSimpleState() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1597:2: ( ( ( rule__SimpleState__Group__0 ) ) )
-            // InternalRoom.g:1598:1: ( ( rule__SimpleState__Group__0 ) )
+            // InternalRoom.g:1625:2: ( ( ( rule__SimpleState__Group__0 ) ) )
+            // InternalRoom.g:1626:1: ( ( rule__SimpleState__Group__0 ) )
             {
-            // InternalRoom.g:1598:1: ( ( rule__SimpleState__Group__0 ) )
-            // InternalRoom.g:1599:1: ( rule__SimpleState__Group__0 )
+            // InternalRoom.g:1626:1: ( ( rule__SimpleState__Group__0 ) )
+            // InternalRoom.g:1627:1: ( rule__SimpleState__Group__0 )
             {
              before(grammarAccess.getSimpleStateAccess().getGroup()); 
-            // InternalRoom.g:1600:1: ( rule__SimpleState__Group__0 )
-            // InternalRoom.g:1600:2: rule__SimpleState__Group__0
+            // InternalRoom.g:1628:1: ( rule__SimpleState__Group__0 )
+            // InternalRoom.g:1628:2: rule__SimpleState__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group__0();
@@ -4422,11 +4499,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefinedState"
-    // InternalRoom.g:1612:1: entryRuleRefinedState : ruleRefinedState EOF ;
+    // InternalRoom.g:1640:1: entryRuleRefinedState : ruleRefinedState EOF ;
     public final void entryRuleRefinedState() throws RecognitionException {
         try {
-            // InternalRoom.g:1613:1: ( ruleRefinedState EOF )
-            // InternalRoom.g:1614:1: ruleRefinedState EOF
+            // InternalRoom.g:1641:1: ( ruleRefinedState EOF )
+            // InternalRoom.g:1642:1: ruleRefinedState EOF
             {
              before(grammarAccess.getRefinedStateRule()); 
             pushFollow(FOLLOW_1);
@@ -4452,21 +4529,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefinedState"
-    // InternalRoom.g:1621:1: ruleRefinedState : ( ( rule__RefinedState__Group__0 ) ) ;
+    // InternalRoom.g:1649:1: ruleRefinedState : ( ( rule__RefinedState__Group__0 ) ) ;
     public final void ruleRefinedState() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1625:2: ( ( ( rule__RefinedState__Group__0 ) ) )
-            // InternalRoom.g:1626:1: ( ( rule__RefinedState__Group__0 ) )
+            // InternalRoom.g:1653:2: ( ( ( rule__RefinedState__Group__0 ) ) )
+            // InternalRoom.g:1654:1: ( ( rule__RefinedState__Group__0 ) )
             {
-            // InternalRoom.g:1626:1: ( ( rule__RefinedState__Group__0 ) )
-            // InternalRoom.g:1627:1: ( rule__RefinedState__Group__0 )
+            // InternalRoom.g:1654:1: ( ( rule__RefinedState__Group__0 ) )
+            // InternalRoom.g:1655:1: ( rule__RefinedState__Group__0 )
             {
              before(grammarAccess.getRefinedStateAccess().getGroup()); 
-            // InternalRoom.g:1628:1: ( rule__RefinedState__Group__0 )
-            // InternalRoom.g:1628:2: rule__RefinedState__Group__0
+            // InternalRoom.g:1656:1: ( rule__RefinedState__Group__0 )
+            // InternalRoom.g:1656:2: rule__RefinedState__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group__0();
@@ -4499,11 +4576,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDetailCode"
-    // InternalRoom.g:1640:1: entryRuleDetailCode : ruleDetailCode EOF ;
+    // InternalRoom.g:1668:1: entryRuleDetailCode : ruleDetailCode EOF ;
     public final void entryRuleDetailCode() throws RecognitionException {
         try {
-            // InternalRoom.g:1641:1: ( ruleDetailCode EOF )
-            // InternalRoom.g:1642:1: ruleDetailCode EOF
+            // InternalRoom.g:1669:1: ( ruleDetailCode EOF )
+            // InternalRoom.g:1670:1: ruleDetailCode EOF
             {
              before(grammarAccess.getDetailCodeRule()); 
             pushFollow(FOLLOW_1);
@@ -4529,21 +4606,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDetailCode"
-    // InternalRoom.g:1649:1: ruleDetailCode : ( ( rule__DetailCode__Alternatives ) ) ;
+    // InternalRoom.g:1677:1: ruleDetailCode : ( ( rule__DetailCode__Alternatives ) ) ;
     public final void ruleDetailCode() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1653:2: ( ( ( rule__DetailCode__Alternatives ) ) )
-            // InternalRoom.g:1654:1: ( ( rule__DetailCode__Alternatives ) )
+            // InternalRoom.g:1681:2: ( ( ( rule__DetailCode__Alternatives ) ) )
+            // InternalRoom.g:1682:1: ( ( rule__DetailCode__Alternatives ) )
             {
-            // InternalRoom.g:1654:1: ( ( rule__DetailCode__Alternatives ) )
-            // InternalRoom.g:1655:1: ( rule__DetailCode__Alternatives )
+            // InternalRoom.g:1682:1: ( ( rule__DetailCode__Alternatives ) )
+            // InternalRoom.g:1683:1: ( rule__DetailCode__Alternatives )
             {
              before(grammarAccess.getDetailCodeAccess().getAlternatives()); 
-            // InternalRoom.g:1656:1: ( rule__DetailCode__Alternatives )
-            // InternalRoom.g:1656:2: rule__DetailCode__Alternatives
+            // InternalRoom.g:1684:1: ( rule__DetailCode__Alternatives )
+            // InternalRoom.g:1684:2: rule__DetailCode__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Alternatives();
@@ -4576,11 +4653,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrPoint"
-    // InternalRoom.g:1668:1: entryRuleTrPoint : ruleTrPoint EOF ;
+    // InternalRoom.g:1696:1: entryRuleTrPoint : ruleTrPoint EOF ;
     public final void entryRuleTrPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1669:1: ( ruleTrPoint EOF )
-            // InternalRoom.g:1670:1: ruleTrPoint EOF
+            // InternalRoom.g:1697:1: ( ruleTrPoint EOF )
+            // InternalRoom.g:1698:1: ruleTrPoint EOF
             {
              before(grammarAccess.getTrPointRule()); 
             pushFollow(FOLLOW_1);
@@ -4606,21 +4683,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrPoint"
-    // InternalRoom.g:1677:1: ruleTrPoint : ( ( rule__TrPoint__Alternatives ) ) ;
+    // InternalRoom.g:1705:1: ruleTrPoint : ( ( rule__TrPoint__Alternatives ) ) ;
     public final void ruleTrPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1681:2: ( ( ( rule__TrPoint__Alternatives ) ) )
-            // InternalRoom.g:1682:1: ( ( rule__TrPoint__Alternatives ) )
+            // InternalRoom.g:1709:2: ( ( ( rule__TrPoint__Alternatives ) ) )
+            // InternalRoom.g:1710:1: ( ( rule__TrPoint__Alternatives ) )
             {
-            // InternalRoom.g:1682:1: ( ( rule__TrPoint__Alternatives ) )
-            // InternalRoom.g:1683:1: ( rule__TrPoint__Alternatives )
+            // InternalRoom.g:1710:1: ( ( rule__TrPoint__Alternatives ) )
+            // InternalRoom.g:1711:1: ( rule__TrPoint__Alternatives )
             {
              before(grammarAccess.getTrPointAccess().getAlternatives()); 
-            // InternalRoom.g:1684:1: ( rule__TrPoint__Alternatives )
-            // InternalRoom.g:1684:2: rule__TrPoint__Alternatives
+            // InternalRoom.g:1712:1: ( rule__TrPoint__Alternatives )
+            // InternalRoom.g:1712:2: rule__TrPoint__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TrPoint__Alternatives();
@@ -4653,11 +4730,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionPoint"
-    // InternalRoom.g:1696:1: entryRuleTransitionPoint : ruleTransitionPoint EOF ;
+    // InternalRoom.g:1724:1: entryRuleTransitionPoint : ruleTransitionPoint EOF ;
     public final void entryRuleTransitionPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1697:1: ( ruleTransitionPoint EOF )
-            // InternalRoom.g:1698:1: ruleTransitionPoint EOF
+            // InternalRoom.g:1725:1: ( ruleTransitionPoint EOF )
+            // InternalRoom.g:1726:1: ruleTransitionPoint EOF
             {
              before(grammarAccess.getTransitionPointRule()); 
             pushFollow(FOLLOW_1);
@@ -4683,21 +4760,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionPoint"
-    // InternalRoom.g:1705:1: ruleTransitionPoint : ( ( rule__TransitionPoint__Group__0 ) ) ;
+    // InternalRoom.g:1733:1: ruleTransitionPoint : ( ( rule__TransitionPoint__Group__0 ) ) ;
     public final void ruleTransitionPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1709:2: ( ( ( rule__TransitionPoint__Group__0 ) ) )
-            // InternalRoom.g:1710:1: ( ( rule__TransitionPoint__Group__0 ) )
+            // InternalRoom.g:1737:2: ( ( ( rule__TransitionPoint__Group__0 ) ) )
+            // InternalRoom.g:1738:1: ( ( rule__TransitionPoint__Group__0 ) )
             {
-            // InternalRoom.g:1710:1: ( ( rule__TransitionPoint__Group__0 ) )
-            // InternalRoom.g:1711:1: ( rule__TransitionPoint__Group__0 )
+            // InternalRoom.g:1738:1: ( ( rule__TransitionPoint__Group__0 ) )
+            // InternalRoom.g:1739:1: ( rule__TransitionPoint__Group__0 )
             {
              before(grammarAccess.getTransitionPointAccess().getGroup()); 
-            // InternalRoom.g:1712:1: ( rule__TransitionPoint__Group__0 )
-            // InternalRoom.g:1712:2: rule__TransitionPoint__Group__0
+            // InternalRoom.g:1740:1: ( rule__TransitionPoint__Group__0 )
+            // InternalRoom.g:1740:2: rule__TransitionPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__Group__0();
@@ -4730,11 +4807,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEntryPoint"
-    // InternalRoom.g:1724:1: entryRuleEntryPoint : ruleEntryPoint EOF ;
+    // InternalRoom.g:1752:1: entryRuleEntryPoint : ruleEntryPoint EOF ;
     public final void entryRuleEntryPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1725:1: ( ruleEntryPoint EOF )
-            // InternalRoom.g:1726:1: ruleEntryPoint EOF
+            // InternalRoom.g:1753:1: ( ruleEntryPoint EOF )
+            // InternalRoom.g:1754:1: ruleEntryPoint EOF
             {
              before(grammarAccess.getEntryPointRule()); 
             pushFollow(FOLLOW_1);
@@ -4760,21 +4837,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEntryPoint"
-    // InternalRoom.g:1733:1: ruleEntryPoint : ( ( rule__EntryPoint__Group__0 ) ) ;
+    // InternalRoom.g:1761:1: ruleEntryPoint : ( ( rule__EntryPoint__Group__0 ) ) ;
     public final void ruleEntryPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1737:2: ( ( ( rule__EntryPoint__Group__0 ) ) )
-            // InternalRoom.g:1738:1: ( ( rule__EntryPoint__Group__0 ) )
+            // InternalRoom.g:1765:2: ( ( ( rule__EntryPoint__Group__0 ) ) )
+            // InternalRoom.g:1766:1: ( ( rule__EntryPoint__Group__0 ) )
             {
-            // InternalRoom.g:1738:1: ( ( rule__EntryPoint__Group__0 ) )
-            // InternalRoom.g:1739:1: ( rule__EntryPoint__Group__0 )
+            // InternalRoom.g:1766:1: ( ( rule__EntryPoint__Group__0 ) )
+            // InternalRoom.g:1767:1: ( rule__EntryPoint__Group__0 )
             {
              before(grammarAccess.getEntryPointAccess().getGroup()); 
-            // InternalRoom.g:1740:1: ( rule__EntryPoint__Group__0 )
-            // InternalRoom.g:1740:2: rule__EntryPoint__Group__0
+            // InternalRoom.g:1768:1: ( rule__EntryPoint__Group__0 )
+            // InternalRoom.g:1768:2: rule__EntryPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__Group__0();
@@ -4807,11 +4884,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleExitPoint"
-    // InternalRoom.g:1752:1: entryRuleExitPoint : ruleExitPoint EOF ;
+    // InternalRoom.g:1780:1: entryRuleExitPoint : ruleExitPoint EOF ;
     public final void entryRuleExitPoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1753:1: ( ruleExitPoint EOF )
-            // InternalRoom.g:1754:1: ruleExitPoint EOF
+            // InternalRoom.g:1781:1: ( ruleExitPoint EOF )
+            // InternalRoom.g:1782:1: ruleExitPoint EOF
             {
              before(grammarAccess.getExitPointRule()); 
             pushFollow(FOLLOW_1);
@@ -4837,21 +4914,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleExitPoint"
-    // InternalRoom.g:1761:1: ruleExitPoint : ( ( rule__ExitPoint__Group__0 ) ) ;
+    // InternalRoom.g:1789:1: ruleExitPoint : ( ( rule__ExitPoint__Group__0 ) ) ;
     public final void ruleExitPoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1765:2: ( ( ( rule__ExitPoint__Group__0 ) ) )
-            // InternalRoom.g:1766:1: ( ( rule__ExitPoint__Group__0 ) )
+            // InternalRoom.g:1793:2: ( ( ( rule__ExitPoint__Group__0 ) ) )
+            // InternalRoom.g:1794:1: ( ( rule__ExitPoint__Group__0 ) )
             {
-            // InternalRoom.g:1766:1: ( ( rule__ExitPoint__Group__0 ) )
-            // InternalRoom.g:1767:1: ( rule__ExitPoint__Group__0 )
+            // InternalRoom.g:1794:1: ( ( rule__ExitPoint__Group__0 ) )
+            // InternalRoom.g:1795:1: ( rule__ExitPoint__Group__0 )
             {
              before(grammarAccess.getExitPointAccess().getGroup()); 
-            // InternalRoom.g:1768:1: ( rule__ExitPoint__Group__0 )
-            // InternalRoom.g:1768:2: rule__ExitPoint__Group__0
+            // InternalRoom.g:1796:1: ( rule__ExitPoint__Group__0 )
+            // InternalRoom.g:1796:2: rule__ExitPoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__Group__0();
@@ -4884,11 +4961,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleChoicePoint"
-    // InternalRoom.g:1780:1: entryRuleChoicePoint : ruleChoicePoint EOF ;
+    // InternalRoom.g:1808:1: entryRuleChoicePoint : ruleChoicePoint EOF ;
     public final void entryRuleChoicePoint() throws RecognitionException {
         try {
-            // InternalRoom.g:1781:1: ( ruleChoicePoint EOF )
-            // InternalRoom.g:1782:1: ruleChoicePoint EOF
+            // InternalRoom.g:1809:1: ( ruleChoicePoint EOF )
+            // InternalRoom.g:1810:1: ruleChoicePoint EOF
             {
              before(grammarAccess.getChoicePointRule()); 
             pushFollow(FOLLOW_1);
@@ -4914,21 +4991,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleChoicePoint"
-    // InternalRoom.g:1789:1: ruleChoicePoint : ( ( rule__ChoicePoint__Group__0 ) ) ;
+    // InternalRoom.g:1817:1: ruleChoicePoint : ( ( rule__ChoicePoint__Group__0 ) ) ;
     public final void ruleChoicePoint() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1793:2: ( ( ( rule__ChoicePoint__Group__0 ) ) )
-            // InternalRoom.g:1794:1: ( ( rule__ChoicePoint__Group__0 ) )
+            // InternalRoom.g:1821:2: ( ( ( rule__ChoicePoint__Group__0 ) ) )
+            // InternalRoom.g:1822:1: ( ( rule__ChoicePoint__Group__0 ) )
             {
-            // InternalRoom.g:1794:1: ( ( rule__ChoicePoint__Group__0 ) )
-            // InternalRoom.g:1795:1: ( rule__ChoicePoint__Group__0 )
+            // InternalRoom.g:1822:1: ( ( rule__ChoicePoint__Group__0 ) )
+            // InternalRoom.g:1823:1: ( rule__ChoicePoint__Group__0 )
             {
              before(grammarAccess.getChoicePointAccess().getGroup()); 
-            // InternalRoom.g:1796:1: ( rule__ChoicePoint__Group__0 )
-            // InternalRoom.g:1796:2: rule__ChoicePoint__Group__0
+            // InternalRoom.g:1824:1: ( rule__ChoicePoint__Group__0 )
+            // InternalRoom.g:1824:2: rule__ChoicePoint__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__Group__0();
@@ -4960,12 +5037,89 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalRoom.g:1836:1: entryRuleTransitionBase : ruleTransitionBase EOF ;
+    public final void entryRuleTransitionBase() throws RecognitionException {
+        try {
+            // InternalRoom.g:1837:1: ( ruleTransitionBase EOF )
+            // InternalRoom.g:1838:1: ruleTransitionBase EOF
+            {
+             before(grammarAccess.getTransitionBaseRule()); 
+            pushFollow(FOLLOW_1);
+            ruleTransitionBase();
+
+            state._fsp--;
+
+             after(grammarAccess.getTransitionBaseRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleTransitionBase"
+
+
+    // $ANTLR start "ruleTransitionBase"
+    // InternalRoom.g:1845:1: ruleTransitionBase : ( ( rule__TransitionBase__Alternatives ) ) ;
+    public final void ruleTransitionBase() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:1849:2: ( ( ( rule__TransitionBase__Alternatives ) ) )
+            // InternalRoom.g:1850:1: ( ( rule__TransitionBase__Alternatives ) )
+            {
+            // InternalRoom.g:1850:1: ( ( rule__TransitionBase__Alternatives ) )
+            // InternalRoom.g:1851:1: ( rule__TransitionBase__Alternatives )
+            {
+             before(grammarAccess.getTransitionBaseAccess().getAlternatives()); 
+            // InternalRoom.g:1852:1: ( rule__TransitionBase__Alternatives )
+            // InternalRoom.g:1852:2: rule__TransitionBase__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__TransitionBase__Alternatives();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getTransitionBaseAccess().getAlternatives()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleTransitionBase"
+
+
     // $ANTLR start "entryRuleTransition"
-    // InternalRoom.g:1810:1: entryRuleTransition : ruleTransition EOF ;
+    // InternalRoom.g:1864:1: entryRuleTransition : ruleTransition EOF ;
     public final void entryRuleTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1811:1: ( ruleTransition EOF )
-            // InternalRoom.g:1812:1: ruleTransition EOF
+            // InternalRoom.g:1865:1: ( ruleTransition EOF )
+            // InternalRoom.g:1866:1: ruleTransition EOF
             {
              before(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -4991,21 +5145,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransition"
-    // InternalRoom.g:1819:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ;
+    // InternalRoom.g:1873:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ;
     public final void ruleTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1823:2: ( ( ( rule__Transition__Alternatives ) ) )
-            // InternalRoom.g:1824:1: ( ( rule__Transition__Alternatives ) )
+            // InternalRoom.g:1877:2: ( ( ( rule__Transition__Alternatives ) ) )
+            // InternalRoom.g:1878:1: ( ( rule__Transition__Alternatives ) )
             {
-            // InternalRoom.g:1824:1: ( ( rule__Transition__Alternatives ) )
-            // InternalRoom.g:1825:1: ( rule__Transition__Alternatives )
+            // InternalRoom.g:1878:1: ( ( rule__Transition__Alternatives ) )
+            // InternalRoom.g:1879:1: ( rule__Transition__Alternatives )
             {
              before(grammarAccess.getTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1826:1: ( rule__Transition__Alternatives )
-            // InternalRoom.g:1826:2: rule__Transition__Alternatives
+            // InternalRoom.g:1880:1: ( rule__Transition__Alternatives )
+            // InternalRoom.g:1880:2: rule__Transition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Transition__Alternatives();
@@ -5038,11 +5192,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalRoom.g:1838:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ;
+    // InternalRoom.g:1892:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ;
     public final void entryRuleNonInitialTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1839:1: ( ruleNonInitialTransition EOF )
-            // InternalRoom.g:1840:1: ruleNonInitialTransition EOF
+            // InternalRoom.g:1893:1: ( ruleNonInitialTransition EOF )
+            // InternalRoom.g:1894:1: ruleNonInitialTransition EOF
             {
              before(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5068,21 +5222,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNonInitialTransition"
-    // InternalRoom.g:1847:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ;
+    // InternalRoom.g:1901:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ;
     public final void ruleNonInitialTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1851:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) )
-            // InternalRoom.g:1852:1: ( ( rule__NonInitialTransition__Alternatives ) )
+            // InternalRoom.g:1905:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) )
+            // InternalRoom.g:1906:1: ( ( rule__NonInitialTransition__Alternatives ) )
             {
-            // InternalRoom.g:1852:1: ( ( rule__NonInitialTransition__Alternatives ) )
-            // InternalRoom.g:1853:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalRoom.g:1906:1: ( ( rule__NonInitialTransition__Alternatives ) )
+            // InternalRoom.g:1907:1: ( rule__NonInitialTransition__Alternatives )
             {
              before(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1854:1: ( rule__NonInitialTransition__Alternatives )
-            // InternalRoom.g:1854:2: rule__NonInitialTransition__Alternatives
+            // InternalRoom.g:1908:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalRoom.g:1908:2: rule__NonInitialTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NonInitialTransition__Alternatives();
@@ -5115,11 +5269,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalRoom.g:1866:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ;
+    // InternalRoom.g:1920:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ;
     public final void entryRuleTransitionChainStartTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1867:1: ( ruleTransitionChainStartTransition EOF )
-            // InternalRoom.g:1868:1: ruleTransitionChainStartTransition EOF
+            // InternalRoom.g:1921:1: ( ruleTransitionChainStartTransition EOF )
+            // InternalRoom.g:1922:1: ruleTransitionChainStartTransition EOF
             {
              before(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5145,21 +5299,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionChainStartTransition"
-    // InternalRoom.g:1875:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ;
+    // InternalRoom.g:1929:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ;
     public final void ruleTransitionChainStartTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1879:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) )
-            // InternalRoom.g:1880:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
+            // InternalRoom.g:1933:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) )
+            // InternalRoom.g:1934:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
             {
-            // InternalRoom.g:1880:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
-            // InternalRoom.g:1881:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalRoom.g:1934:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
+            // InternalRoom.g:1935:1: ( rule__TransitionChainStartTransition__Alternatives )
             {
              before(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1882:1: ( rule__TransitionChainStartTransition__Alternatives )
-            // InternalRoom.g:1882:2: rule__TransitionChainStartTransition__Alternatives
+            // InternalRoom.g:1936:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalRoom.g:1936:2: rule__TransitionChainStartTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionChainStartTransition__Alternatives();
@@ -5192,11 +5346,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalRoom.g:1894:1: entryRuleInitialTransition : ruleInitialTransition EOF ;
+    // InternalRoom.g:1948:1: entryRuleInitialTransition : ruleInitialTransition EOF ;
     public final void entryRuleInitialTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1895:1: ( ruleInitialTransition EOF )
-            // InternalRoom.g:1896:1: ruleInitialTransition EOF
+            // InternalRoom.g:1949:1: ( ruleInitialTransition EOF )
+            // InternalRoom.g:1950:1: ruleInitialTransition EOF
             {
              before(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5222,21 +5376,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInitialTransition"
-    // InternalRoom.g:1903:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ;
+    // InternalRoom.g:1957:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ;
     public final void ruleInitialTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1907:2: ( ( ( rule__InitialTransition__Group__0 ) ) )
-            // InternalRoom.g:1908:1: ( ( rule__InitialTransition__Group__0 ) )
+            // InternalRoom.g:1961:2: ( ( ( rule__InitialTransition__Group__0 ) ) )
+            // InternalRoom.g:1962:1: ( ( rule__InitialTransition__Group__0 ) )
             {
-            // InternalRoom.g:1908:1: ( ( rule__InitialTransition__Group__0 ) )
-            // InternalRoom.g:1909:1: ( rule__InitialTransition__Group__0 )
+            // InternalRoom.g:1962:1: ( ( rule__InitialTransition__Group__0 ) )
+            // InternalRoom.g:1963:1: ( rule__InitialTransition__Group__0 )
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup()); 
-            // InternalRoom.g:1910:1: ( rule__InitialTransition__Group__0 )
-            // InternalRoom.g:1910:2: rule__InitialTransition__Group__0
+            // InternalRoom.g:1964:1: ( rule__InitialTransition__Group__0 )
+            // InternalRoom.g:1964:2: rule__InitialTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__0();
@@ -5269,11 +5423,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalRoom.g:1922:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ;
+    // InternalRoom.g:1976:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ;
     public final void entryRuleContinuationTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1923:1: ( ruleContinuationTransition EOF )
-            // InternalRoom.g:1924:1: ruleContinuationTransition EOF
+            // InternalRoom.g:1977:1: ( ruleContinuationTransition EOF )
+            // InternalRoom.g:1978:1: ruleContinuationTransition EOF
             {
              before(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5299,21 +5453,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleContinuationTransition"
-    // InternalRoom.g:1931:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ;
+    // InternalRoom.g:1985:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ;
     public final void ruleContinuationTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1935:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) )
-            // InternalRoom.g:1936:1: ( ( rule__ContinuationTransition__Group__0 ) )
+            // InternalRoom.g:1989:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) )
+            // InternalRoom.g:1990:1: ( ( rule__ContinuationTransition__Group__0 ) )
             {
-            // InternalRoom.g:1936:1: ( ( rule__ContinuationTransition__Group__0 ) )
-            // InternalRoom.g:1937:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalRoom.g:1990:1: ( ( rule__ContinuationTransition__Group__0 ) )
+            // InternalRoom.g:1991:1: ( rule__ContinuationTransition__Group__0 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup()); 
-            // InternalRoom.g:1938:1: ( rule__ContinuationTransition__Group__0 )
-            // InternalRoom.g:1938:2: rule__ContinuationTransition__Group__0
+            // InternalRoom.g:1992:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalRoom.g:1992:2: rule__ContinuationTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__0();
@@ -5346,11 +5500,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalRoom.g:1950:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ;
+    // InternalRoom.g:2004:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ;
     public final void entryRuleTriggeredTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1951:1: ( ruleTriggeredTransition EOF )
-            // InternalRoom.g:1952:1: ruleTriggeredTransition EOF
+            // InternalRoom.g:2005:1: ( ruleTriggeredTransition EOF )
+            // InternalRoom.g:2006:1: ruleTriggeredTransition EOF
             {
              before(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5376,21 +5530,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTriggeredTransition"
-    // InternalRoom.g:1959:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ;
+    // InternalRoom.g:2013:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ;
     public final void ruleTriggeredTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1963:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) )
-            // InternalRoom.g:1964:1: ( ( rule__TriggeredTransition__Group__0 ) )
+            // InternalRoom.g:2017:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) )
+            // InternalRoom.g:2018:1: ( ( rule__TriggeredTransition__Group__0 ) )
             {
-            // InternalRoom.g:1964:1: ( ( rule__TriggeredTransition__Group__0 ) )
-            // InternalRoom.g:1965:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalRoom.g:2018:1: ( ( rule__TriggeredTransition__Group__0 ) )
+            // InternalRoom.g:2019:1: ( rule__TriggeredTransition__Group__0 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup()); 
-            // InternalRoom.g:1966:1: ( rule__TriggeredTransition__Group__0 )
-            // InternalRoom.g:1966:2: rule__TriggeredTransition__Group__0
+            // InternalRoom.g:2020:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalRoom.g:2020:2: rule__TriggeredTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__0();
@@ -5423,11 +5577,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalRoom.g:1978:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ;
+    // InternalRoom.g:2032:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ;
     public final void entryRuleGuardedTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:1979:1: ( ruleGuardedTransition EOF )
-            // InternalRoom.g:1980:1: ruleGuardedTransition EOF
+            // InternalRoom.g:2033:1: ( ruleGuardedTransition EOF )
+            // InternalRoom.g:2034:1: ruleGuardedTransition EOF
             {
              before(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5453,21 +5607,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuardedTransition"
-    // InternalRoom.g:1987:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ;
+    // InternalRoom.g:2041:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ;
     public final void ruleGuardedTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:1991:2: ( ( ( rule__GuardedTransition__Group__0 ) ) )
-            // InternalRoom.g:1992:1: ( ( rule__GuardedTransition__Group__0 ) )
+            // InternalRoom.g:2045:2: ( ( ( rule__GuardedTransition__Group__0 ) ) )
+            // InternalRoom.g:2046:1: ( ( rule__GuardedTransition__Group__0 ) )
             {
-            // InternalRoom.g:1992:1: ( ( rule__GuardedTransition__Group__0 ) )
-            // InternalRoom.g:1993:1: ( rule__GuardedTransition__Group__0 )
+            // InternalRoom.g:2046:1: ( ( rule__GuardedTransition__Group__0 ) )
+            // InternalRoom.g:2047:1: ( rule__GuardedTransition__Group__0 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getGroup()); 
-            // InternalRoom.g:1994:1: ( rule__GuardedTransition__Group__0 )
-            // InternalRoom.g:1994:2: rule__GuardedTransition__Group__0
+            // InternalRoom.g:2048:1: ( rule__GuardedTransition__Group__0 )
+            // InternalRoom.g:2048:2: rule__GuardedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__0();
@@ -5500,11 +5654,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalRoom.g:2006:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ;
+    // InternalRoom.g:2060:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ;
     public final void entryRuleCPBranchTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:2007:1: ( ruleCPBranchTransition EOF )
-            // InternalRoom.g:2008:1: ruleCPBranchTransition EOF
+            // InternalRoom.g:2061:1: ( ruleCPBranchTransition EOF )
+            // InternalRoom.g:2062:1: ruleCPBranchTransition EOF
             {
              before(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5530,21 +5684,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCPBranchTransition"
-    // InternalRoom.g:2015:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ;
+    // InternalRoom.g:2069:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ;
     public final void ruleCPBranchTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2019:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) )
-            // InternalRoom.g:2020:1: ( ( rule__CPBranchTransition__Group__0 ) )
+            // InternalRoom.g:2073:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) )
+            // InternalRoom.g:2074:1: ( ( rule__CPBranchTransition__Group__0 ) )
             {
-            // InternalRoom.g:2020:1: ( ( rule__CPBranchTransition__Group__0 ) )
-            // InternalRoom.g:2021:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalRoom.g:2074:1: ( ( rule__CPBranchTransition__Group__0 ) )
+            // InternalRoom.g:2075:1: ( rule__CPBranchTransition__Group__0 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getGroup()); 
-            // InternalRoom.g:2022:1: ( rule__CPBranchTransition__Group__0 )
-            // InternalRoom.g:2022:2: rule__CPBranchTransition__Group__0
+            // InternalRoom.g:2076:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalRoom.g:2076:2: rule__CPBranchTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__0();
@@ -5577,11 +5731,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalRoom.g:2034:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ;
+    // InternalRoom.g:2088:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ;
     public final void entryRuleRefinedTransition() throws RecognitionException {
         try {
-            // InternalRoom.g:2035:1: ( ruleRefinedTransition EOF )
-            // InternalRoom.g:2036:1: ruleRefinedTransition EOF
+            // InternalRoom.g:2089:1: ( ruleRefinedTransition EOF )
+            // InternalRoom.g:2090:1: ruleRefinedTransition EOF
             {
              before(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5607,21 +5761,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefinedTransition"
-    // InternalRoom.g:2043:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ;
+    // InternalRoom.g:2097:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ;
     public final void ruleRefinedTransition() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2047:2: ( ( ( rule__RefinedTransition__Group__0 ) ) )
-            // InternalRoom.g:2048:1: ( ( rule__RefinedTransition__Group__0 ) )
+            // InternalRoom.g:2101:2: ( ( ( rule__RefinedTransition__Group__0 ) ) )
+            // InternalRoom.g:2102:1: ( ( rule__RefinedTransition__Group__0 ) )
             {
-            // InternalRoom.g:2048:1: ( ( rule__RefinedTransition__Group__0 ) )
-            // InternalRoom.g:2049:1: ( rule__RefinedTransition__Group__0 )
+            // InternalRoom.g:2102:1: ( ( rule__RefinedTransition__Group__0 ) )
+            // InternalRoom.g:2103:1: ( rule__RefinedTransition__Group__0 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getGroup()); 
-            // InternalRoom.g:2050:1: ( rule__RefinedTransition__Group__0 )
-            // InternalRoom.g:2050:2: rule__RefinedTransition__Group__0
+            // InternalRoom.g:2104:1: ( rule__RefinedTransition__Group__0 )
+            // InternalRoom.g:2104:2: rule__RefinedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__0();
@@ -5654,11 +5808,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalRoom.g:2062:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ;
+    // InternalRoom.g:2116:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ;
     public final void entryRuleTransitionTerminal() throws RecognitionException {
         try {
-            // InternalRoom.g:2063:1: ( ruleTransitionTerminal EOF )
-            // InternalRoom.g:2064:1: ruleTransitionTerminal EOF
+            // InternalRoom.g:2117:1: ( ruleTransitionTerminal EOF )
+            // InternalRoom.g:2118:1: ruleTransitionTerminal EOF
             {
              before(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5684,21 +5838,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionTerminal"
-    // InternalRoom.g:2071:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ;
+    // InternalRoom.g:2125:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ;
     public final void ruleTransitionTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2075:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) )
-            // InternalRoom.g:2076:1: ( ( rule__TransitionTerminal__Alternatives ) )
+            // InternalRoom.g:2129:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) )
+            // InternalRoom.g:2130:1: ( ( rule__TransitionTerminal__Alternatives ) )
             {
-            // InternalRoom.g:2076:1: ( ( rule__TransitionTerminal__Alternatives ) )
-            // InternalRoom.g:2077:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalRoom.g:2130:1: ( ( rule__TransitionTerminal__Alternatives ) )
+            // InternalRoom.g:2131:1: ( rule__TransitionTerminal__Alternatives )
             {
              before(grammarAccess.getTransitionTerminalAccess().getAlternatives()); 
-            // InternalRoom.g:2078:1: ( rule__TransitionTerminal__Alternatives )
-            // InternalRoom.g:2078:2: rule__TransitionTerminal__Alternatives
+            // InternalRoom.g:2132:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalRoom.g:2132:2: rule__TransitionTerminal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionTerminal__Alternatives();
@@ -5731,11 +5885,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalRoom.g:2090:1: entryRuleStateTerminal : ruleStateTerminal EOF ;
+    // InternalRoom.g:2144:1: entryRuleStateTerminal : ruleStateTerminal EOF ;
     public final void entryRuleStateTerminal() throws RecognitionException {
         try {
-            // InternalRoom.g:2091:1: ( ruleStateTerminal EOF )
-            // InternalRoom.g:2092:1: ruleStateTerminal EOF
+            // InternalRoom.g:2145:1: ( ruleStateTerminal EOF )
+            // InternalRoom.g:2146:1: ruleStateTerminal EOF
             {
              before(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5761,21 +5915,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalRoom.g:2099:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ;
+    // InternalRoom.g:2153:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ;
     public final void ruleStateTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2103:2: ( ( ( rule__StateTerminal__StateAssignment ) ) )
-            // InternalRoom.g:2104:1: ( ( rule__StateTerminal__StateAssignment ) )
+            // InternalRoom.g:2157:2: ( ( ( rule__StateTerminal__StateAssignment ) ) )
+            // InternalRoom.g:2158:1: ( ( rule__StateTerminal__StateAssignment ) )
             {
-            // InternalRoom.g:2104:1: ( ( rule__StateTerminal__StateAssignment ) )
-            // InternalRoom.g:2105:1: ( rule__StateTerminal__StateAssignment )
+            // InternalRoom.g:2158:1: ( ( rule__StateTerminal__StateAssignment ) )
+            // InternalRoom.g:2159:1: ( rule__StateTerminal__StateAssignment )
             {
              before(grammarAccess.getStateTerminalAccess().getStateAssignment()); 
-            // InternalRoom.g:2106:1: ( rule__StateTerminal__StateAssignment )
-            // InternalRoom.g:2106:2: rule__StateTerminal__StateAssignment
+            // InternalRoom.g:2160:1: ( rule__StateTerminal__StateAssignment )
+            // InternalRoom.g:2160:2: rule__StateTerminal__StateAssignment
             {
             pushFollow(FOLLOW_2);
             rule__StateTerminal__StateAssignment();
@@ -5808,11 +5962,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalRoom.g:2118:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ;
+    // InternalRoom.g:2172:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ;
     public final void entryRuleTrPointTerminal() throws RecognitionException {
         try {
-            // InternalRoom.g:2119:1: ( ruleTrPointTerminal EOF )
-            // InternalRoom.g:2120:1: ruleTrPointTerminal EOF
+            // InternalRoom.g:2173:1: ( ruleTrPointTerminal EOF )
+            // InternalRoom.g:2174:1: ruleTrPointTerminal EOF
             {
              before(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5838,21 +5992,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrPointTerminal"
-    // InternalRoom.g:2127:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2181:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ;
     public final void ruleTrPointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2131:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) )
-            // InternalRoom.g:2132:1: ( ( rule__TrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2185:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2186:1: ( ( rule__TrPointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2132:1: ( ( rule__TrPointTerminal__Group__0 ) )
-            // InternalRoom.g:2133:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalRoom.g:2186:1: ( ( rule__TrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2187:1: ( rule__TrPointTerminal__Group__0 )
             {
              before(grammarAccess.getTrPointTerminalAccess().getGroup()); 
-            // InternalRoom.g:2134:1: ( rule__TrPointTerminal__Group__0 )
-            // InternalRoom.g:2134:2: rule__TrPointTerminal__Group__0
+            // InternalRoom.g:2188:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalRoom.g:2188:2: rule__TrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__0();
@@ -5885,11 +6039,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalRoom.g:2146:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ;
+    // InternalRoom.g:2200:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ;
     public final void entryRuleSubStateTrPointTerminal() throws RecognitionException {
         try {
-            // InternalRoom.g:2147:1: ( ruleSubStateTrPointTerminal EOF )
-            // InternalRoom.g:2148:1: ruleSubStateTrPointTerminal EOF
+            // InternalRoom.g:2201:1: ( ruleSubStateTrPointTerminal EOF )
+            // InternalRoom.g:2202:1: ruleSubStateTrPointTerminal EOF
             {
              before(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5915,21 +6069,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubStateTrPointTerminal"
-    // InternalRoom.g:2155:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2209:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ;
     public final void ruleSubStateTrPointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2159:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) )
-            // InternalRoom.g:2160:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2213:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2214:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2160:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
-            // InternalRoom.g:2161:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalRoom.g:2214:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2215:1: ( rule__SubStateTrPointTerminal__Group__0 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); 
-            // InternalRoom.g:2162:1: ( rule__SubStateTrPointTerminal__Group__0 )
-            // InternalRoom.g:2162:2: rule__SubStateTrPointTerminal__Group__0
+            // InternalRoom.g:2216:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalRoom.g:2216:2: rule__SubStateTrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__0();
@@ -5962,11 +6116,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalRoom.g:2174:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ;
+    // InternalRoom.g:2228:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ;
     public final void entryRuleChoicepointTerminal() throws RecognitionException {
         try {
-            // InternalRoom.g:2175:1: ( ruleChoicepointTerminal EOF )
-            // InternalRoom.g:2176:1: ruleChoicepointTerminal EOF
+            // InternalRoom.g:2229:1: ( ruleChoicepointTerminal EOF )
+            // InternalRoom.g:2230:1: ruleChoicepointTerminal EOF
             {
              before(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5992,21 +6146,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleChoicepointTerminal"
-    // InternalRoom.g:2183:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2237:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ;
     public final void ruleChoicepointTerminal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2187:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) )
-            // InternalRoom.g:2188:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
+            // InternalRoom.g:2241:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2242:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2188:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
-            // InternalRoom.g:2189:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalRoom.g:2242:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
+            // InternalRoom.g:2243:1: ( rule__ChoicepointTerminal__Group__0 )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getGroup()); 
-            // InternalRoom.g:2190:1: ( rule__ChoicepointTerminal__Group__0 )
-            // InternalRoom.g:2190:2: rule__ChoicepointTerminal__Group__0
+            // InternalRoom.g:2244:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalRoom.g:2244:2: rule__ChoicepointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__0();
@@ -6039,11 +6193,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalRoom.g:2202:1: entryRuleTrigger : ruleTrigger EOF ;
+    // InternalRoom.g:2256:1: entryRuleTrigger : ruleTrigger EOF ;
     public final void entryRuleTrigger() throws RecognitionException {
         try {
-            // InternalRoom.g:2203:1: ( ruleTrigger EOF )
-            // InternalRoom.g:2204:1: ruleTrigger EOF
+            // InternalRoom.g:2257:1: ( ruleTrigger EOF )
+            // InternalRoom.g:2258:1: ruleTrigger EOF
             {
              before(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -6069,21 +6223,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrigger"
-    // InternalRoom.g:2211:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ;
+    // InternalRoom.g:2265:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ;
     public final void ruleTrigger() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2215:2: ( ( ( rule__Trigger__Group__0 ) ) )
-            // InternalRoom.g:2216:1: ( ( rule__Trigger__Group__0 ) )
+            // InternalRoom.g:2269:2: ( ( ( rule__Trigger__Group__0 ) ) )
+            // InternalRoom.g:2270:1: ( ( rule__Trigger__Group__0 ) )
             {
-            // InternalRoom.g:2216:1: ( ( rule__Trigger__Group__0 ) )
-            // InternalRoom.g:2217:1: ( rule__Trigger__Group__0 )
+            // InternalRoom.g:2270:1: ( ( rule__Trigger__Group__0 ) )
+            // InternalRoom.g:2271:1: ( rule__Trigger__Group__0 )
             {
              before(grammarAccess.getTriggerAccess().getGroup()); 
-            // InternalRoom.g:2218:1: ( rule__Trigger__Group__0 )
-            // InternalRoom.g:2218:2: rule__Trigger__Group__0
+            // InternalRoom.g:2272:1: ( rule__Trigger__Group__0 )
+            // InternalRoom.g:2272:2: rule__Trigger__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__0();
@@ -6116,11 +6270,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalRoom.g:2230:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ;
+    // InternalRoom.g:2284:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ;
     public final void entryRuleMessageFromIf() throws RecognitionException {
         try {
-            // InternalRoom.g:2231:1: ( ruleMessageFromIf EOF )
-            // InternalRoom.g:2232:1: ruleMessageFromIf EOF
+            // InternalRoom.g:2285:1: ( ruleMessageFromIf EOF )
+            // InternalRoom.g:2286:1: ruleMessageFromIf EOF
             {
              before(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -6146,21 +6300,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMessageFromIf"
-    // InternalRoom.g:2239:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ;
+    // InternalRoom.g:2293:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ;
     public final void ruleMessageFromIf() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2243:2: ( ( ( rule__MessageFromIf__Group__0 ) ) )
-            // InternalRoom.g:2244:1: ( ( rule__MessageFromIf__Group__0 ) )
+            // InternalRoom.g:2297:2: ( ( ( rule__MessageFromIf__Group__0 ) ) )
+            // InternalRoom.g:2298:1: ( ( rule__MessageFromIf__Group__0 ) )
             {
-            // InternalRoom.g:2244:1: ( ( rule__MessageFromIf__Group__0 ) )
-            // InternalRoom.g:2245:1: ( rule__MessageFromIf__Group__0 )
+            // InternalRoom.g:2298:1: ( ( rule__MessageFromIf__Group__0 ) )
+            // InternalRoom.g:2299:1: ( rule__MessageFromIf__Group__0 )
             {
              before(grammarAccess.getMessageFromIfAccess().getGroup()); 
-            // InternalRoom.g:2246:1: ( rule__MessageFromIf__Group__0 )
-            // InternalRoom.g:2246:2: rule__MessageFromIf__Group__0
+            // InternalRoom.g:2300:1: ( rule__MessageFromIf__Group__0 )
+            // InternalRoom.g:2300:2: rule__MessageFromIf__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__0();
@@ -6193,11 +6347,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalRoom.g:2258:1: entryRuleGuard : ruleGuard EOF ;
+    // InternalRoom.g:2312:1: entryRuleGuard : ruleGuard EOF ;
     public final void entryRuleGuard() throws RecognitionException {
         try {
-            // InternalRoom.g:2259:1: ( ruleGuard EOF )
-            // InternalRoom.g:2260:1: ruleGuard EOF
+            // InternalRoom.g:2313:1: ( ruleGuard EOF )
+            // InternalRoom.g:2314:1: ruleGuard EOF
             {
              before(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -6223,21 +6377,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuard"
-    // InternalRoom.g:2267:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ;
+    // InternalRoom.g:2321:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ;
     public final void ruleGuard() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2271:2: ( ( ( rule__Guard__Group__0 ) ) )
-            // InternalRoom.g:2272:1: ( ( rule__Guard__Group__0 ) )
+            // InternalRoom.g:2325:2: ( ( ( rule__Guard__Group__0 ) ) )
+            // InternalRoom.g:2326:1: ( ( rule__Guard__Group__0 ) )
             {
-            // InternalRoom.g:2272:1: ( ( rule__Guard__Group__0 ) )
-            // InternalRoom.g:2273:1: ( rule__Guard__Group__0 )
+            // InternalRoom.g:2326:1: ( ( rule__Guard__Group__0 ) )
+            // InternalRoom.g:2327:1: ( rule__Guard__Group__0 )
             {
              before(grammarAccess.getGuardAccess().getGroup()); 
-            // InternalRoom.g:2274:1: ( rule__Guard__Group__0 )
-            // InternalRoom.g:2274:2: rule__Guard__Group__0
+            // InternalRoom.g:2328:1: ( rule__Guard__Group__0 )
+            // InternalRoom.g:2328:2: rule__Guard__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__0();
@@ -6270,11 +6424,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleProtocolSemantics"
-    // InternalRoom.g:2286:1: entryRuleProtocolSemantics : ruleProtocolSemantics EOF ;
+    // InternalRoom.g:2340:1: entryRuleProtocolSemantics : ruleProtocolSemantics EOF ;
     public final void entryRuleProtocolSemantics() throws RecognitionException {
         try {
-            // InternalRoom.g:2287:1: ( ruleProtocolSemantics EOF )
-            // InternalRoom.g:2288:1: ruleProtocolSemantics EOF
+            // InternalRoom.g:2341:1: ( ruleProtocolSemantics EOF )
+            // InternalRoom.g:2342:1: ruleProtocolSemantics EOF
             {
              before(grammarAccess.getProtocolSemanticsRule()); 
             pushFollow(FOLLOW_1);
@@ -6300,21 +6454,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleProtocolSemantics"
-    // InternalRoom.g:2295:1: ruleProtocolSemantics : ( ( rule__ProtocolSemantics__Group__0 ) ) ;
+    // InternalRoom.g:2349:1: ruleProtocolSemantics : ( ( rule__ProtocolSemantics__Group__0 ) ) ;
     public final void ruleProtocolSemantics() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2299:2: ( ( ( rule__ProtocolSemantics__Group__0 ) ) )
-            // InternalRoom.g:2300:1: ( ( rule__ProtocolSemantics__Group__0 ) )
+            // InternalRoom.g:2353:2: ( ( ( rule__ProtocolSemantics__Group__0 ) ) )
+            // InternalRoom.g:2354:1: ( ( rule__ProtocolSemantics__Group__0 ) )
             {
-            // InternalRoom.g:2300:1: ( ( rule__ProtocolSemantics__Group__0 ) )
-            // InternalRoom.g:2301:1: ( rule__ProtocolSemantics__Group__0 )
+            // InternalRoom.g:2354:1: ( ( rule__ProtocolSemantics__Group__0 ) )
+            // InternalRoom.g:2355:1: ( rule__ProtocolSemantics__Group__0 )
             {
              before(grammarAccess.getProtocolSemanticsAccess().getGroup()); 
-            // InternalRoom.g:2302:1: ( rule__ProtocolSemantics__Group__0 )
-            // InternalRoom.g:2302:2: rule__ProtocolSemantics__Group__0
+            // InternalRoom.g:2356:1: ( rule__ProtocolSemantics__Group__0 )
+            // InternalRoom.g:2356:2: rule__ProtocolSemantics__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolSemantics__Group__0();
@@ -6347,11 +6501,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalRoom.g:2314:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ;
+    // InternalRoom.g:2368:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ;
     public final void entryRuleSemanticsRule() throws RecognitionException {
         try {
-            // InternalRoom.g:2315:1: ( ruleSemanticsRule EOF )
-            // InternalRoom.g:2316:1: ruleSemanticsRule EOF
+            // InternalRoom.g:2369:1: ( ruleSemanticsRule EOF )
+            // InternalRoom.g:2370:1: ruleSemanticsRule EOF
             {
              before(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6377,21 +6531,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSemanticsRule"
-    // InternalRoom.g:2323:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ;
+    // InternalRoom.g:2377:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ;
     public final void ruleSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2327:2: ( ( ( rule__SemanticsRule__Alternatives ) ) )
-            // InternalRoom.g:2328:1: ( ( rule__SemanticsRule__Alternatives ) )
+            // InternalRoom.g:2381:2: ( ( ( rule__SemanticsRule__Alternatives ) ) )
+            // InternalRoom.g:2382:1: ( ( rule__SemanticsRule__Alternatives ) )
             {
-            // InternalRoom.g:2328:1: ( ( rule__SemanticsRule__Alternatives ) )
-            // InternalRoom.g:2329:1: ( rule__SemanticsRule__Alternatives )
+            // InternalRoom.g:2382:1: ( ( rule__SemanticsRule__Alternatives ) )
+            // InternalRoom.g:2383:1: ( rule__SemanticsRule__Alternatives )
             {
              before(grammarAccess.getSemanticsRuleAccess().getAlternatives()); 
-            // InternalRoom.g:2330:1: ( rule__SemanticsRule__Alternatives )
-            // InternalRoom.g:2330:2: rule__SemanticsRule__Alternatives
+            // InternalRoom.g:2384:1: ( rule__SemanticsRule__Alternatives )
+            // InternalRoom.g:2384:2: rule__SemanticsRule__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__SemanticsRule__Alternatives();
@@ -6424,11 +6578,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalRoom.g:2342:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ;
+    // InternalRoom.g:2396:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ;
     public final void entryRuleInSemanticsRule() throws RecognitionException {
         try {
-            // InternalRoom.g:2343:1: ( ruleInSemanticsRule EOF )
-            // InternalRoom.g:2344:1: ruleInSemanticsRule EOF
+            // InternalRoom.g:2397:1: ( ruleInSemanticsRule EOF )
+            // InternalRoom.g:2398:1: ruleInSemanticsRule EOF
             {
              before(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6454,21 +6608,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInSemanticsRule"
-    // InternalRoom.g:2351:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ;
+    // InternalRoom.g:2405:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ;
     public final void ruleInSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2355:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) )
-            // InternalRoom.g:2356:1: ( ( rule__InSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2409:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) )
+            // InternalRoom.g:2410:1: ( ( rule__InSemanticsRule__Group__0 ) )
             {
-            // InternalRoom.g:2356:1: ( ( rule__InSemanticsRule__Group__0 ) )
-            // InternalRoom.g:2357:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalRoom.g:2410:1: ( ( rule__InSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2411:1: ( rule__InSemanticsRule__Group__0 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup()); 
-            // InternalRoom.g:2358:1: ( rule__InSemanticsRule__Group__0 )
-            // InternalRoom.g:2358:2: rule__InSemanticsRule__Group__0
+            // InternalRoom.g:2412:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalRoom.g:2412:2: rule__InSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__0();
@@ -6501,11 +6655,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalRoom.g:2370:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ;
+    // InternalRoom.g:2424:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ;
     public final void entryRuleOutSemanticsRule() throws RecognitionException {
         try {
-            // InternalRoom.g:2371:1: ( ruleOutSemanticsRule EOF )
-            // InternalRoom.g:2372:1: ruleOutSemanticsRule EOF
+            // InternalRoom.g:2425:1: ( ruleOutSemanticsRule EOF )
+            // InternalRoom.g:2426:1: ruleOutSemanticsRule EOF
             {
              before(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6531,21 +6685,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleOutSemanticsRule"
-    // InternalRoom.g:2379:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ;
+    // InternalRoom.g:2433:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ;
     public final void ruleOutSemanticsRule() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2383:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) )
-            // InternalRoom.g:2384:1: ( ( rule__OutSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2437:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) )
+            // InternalRoom.g:2438:1: ( ( rule__OutSemanticsRule__Group__0 ) )
             {
-            // InternalRoom.g:2384:1: ( ( rule__OutSemanticsRule__Group__0 ) )
-            // InternalRoom.g:2385:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalRoom.g:2438:1: ( ( rule__OutSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2439:1: ( rule__OutSemanticsRule__Group__0 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup()); 
-            // InternalRoom.g:2386:1: ( rule__OutSemanticsRule__Group__0 )
-            // InternalRoom.g:2386:2: rule__OutSemanticsRule__Group__0
+            // InternalRoom.g:2440:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalRoom.g:2440:2: rule__OutSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__0();
@@ -6578,11 +6732,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotation"
-    // InternalRoom.g:2398:1: entryRuleAnnotation : ruleAnnotation EOF ;
+    // InternalRoom.g:2452:1: entryRuleAnnotation : ruleAnnotation EOF ;
     public final void entryRuleAnnotation() throws RecognitionException {
         try {
-            // InternalRoom.g:2399:1: ( ruleAnnotation EOF )
-            // InternalRoom.g:2400:1: ruleAnnotation EOF
+            // InternalRoom.g:2453:1: ( ruleAnnotation EOF )
+            // InternalRoom.g:2454:1: ruleAnnotation EOF
             {
              before(grammarAccess.getAnnotationRule()); 
             pushFollow(FOLLOW_1);
@@ -6608,21 +6762,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotation"
-    // InternalRoom.g:2407:1: ruleAnnotation : ( ( rule__Annotation__Group__0 ) ) ;
+    // InternalRoom.g:2461:1: ruleAnnotation : ( ( rule__Annotation__Group__0 ) ) ;
     public final void ruleAnnotation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2411:2: ( ( ( rule__Annotation__Group__0 ) ) )
-            // InternalRoom.g:2412:1: ( ( rule__Annotation__Group__0 ) )
+            // InternalRoom.g:2465:2: ( ( ( rule__Annotation__Group__0 ) ) )
+            // InternalRoom.g:2466:1: ( ( rule__Annotation__Group__0 ) )
             {
-            // InternalRoom.g:2412:1: ( ( rule__Annotation__Group__0 ) )
-            // InternalRoom.g:2413:1: ( rule__Annotation__Group__0 )
+            // InternalRoom.g:2466:1: ( ( rule__Annotation__Group__0 ) )
+            // InternalRoom.g:2467:1: ( rule__Annotation__Group__0 )
             {
              before(grammarAccess.getAnnotationAccess().getGroup()); 
-            // InternalRoom.g:2414:1: ( rule__Annotation__Group__0 )
-            // InternalRoom.g:2414:2: rule__Annotation__Group__0
+            // InternalRoom.g:2468:1: ( rule__Annotation__Group__0 )
+            // InternalRoom.g:2468:2: rule__Annotation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group__0();
@@ -6655,11 +6809,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalRoom.g:2426:1: entryRuleKeyValue : ruleKeyValue EOF ;
+    // InternalRoom.g:2480:1: entryRuleKeyValue : ruleKeyValue EOF ;
     public final void entryRuleKeyValue() throws RecognitionException {
         try {
-            // InternalRoom.g:2427:1: ( ruleKeyValue EOF )
-            // InternalRoom.g:2428:1: ruleKeyValue EOF
+            // InternalRoom.g:2481:1: ( ruleKeyValue EOF )
+            // InternalRoom.g:2482:1: ruleKeyValue EOF
             {
              before(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -6685,21 +6839,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleKeyValue"
-    // InternalRoom.g:2435:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ;
+    // InternalRoom.g:2489:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ;
     public final void ruleKeyValue() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2439:2: ( ( ( rule__KeyValue__Group__0 ) ) )
-            // InternalRoom.g:2440:1: ( ( rule__KeyValue__Group__0 ) )
+            // InternalRoom.g:2493:2: ( ( ( rule__KeyValue__Group__0 ) ) )
+            // InternalRoom.g:2494:1: ( ( rule__KeyValue__Group__0 ) )
             {
-            // InternalRoom.g:2440:1: ( ( rule__KeyValue__Group__0 ) )
-            // InternalRoom.g:2441:1: ( rule__KeyValue__Group__0 )
+            // InternalRoom.g:2494:1: ( ( rule__KeyValue__Group__0 ) )
+            // InternalRoom.g:2495:1: ( rule__KeyValue__Group__0 )
             {
              before(grammarAccess.getKeyValueAccess().getGroup()); 
-            // InternalRoom.g:2442:1: ( rule__KeyValue__Group__0 )
-            // InternalRoom.g:2442:2: rule__KeyValue__Group__0
+            // InternalRoom.g:2496:1: ( rule__KeyValue__Group__0 )
+            // InternalRoom.g:2496:2: rule__KeyValue__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__0();
@@ -6732,11 +6886,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationType"
-    // InternalRoom.g:2454:1: entryRuleAnnotationType : ruleAnnotationType EOF ;
+    // InternalRoom.g:2508:1: entryRuleAnnotationType : ruleAnnotationType EOF ;
     public final void entryRuleAnnotationType() throws RecognitionException {
         try {
-            // InternalRoom.g:2455:1: ( ruleAnnotationType EOF )
-            // InternalRoom.g:2456:1: ruleAnnotationType EOF
+            // InternalRoom.g:2509:1: ( ruleAnnotationType EOF )
+            // InternalRoom.g:2510:1: ruleAnnotationType EOF
             {
              before(grammarAccess.getAnnotationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -6762,21 +6916,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationType"
-    // InternalRoom.g:2463:1: ruleAnnotationType : ( ( rule__AnnotationType__Group__0 ) ) ;
+    // InternalRoom.g:2517:1: ruleAnnotationType : ( ( rule__AnnotationType__Group__0 ) ) ;
     public final void ruleAnnotationType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2467:2: ( ( ( rule__AnnotationType__Group__0 ) ) )
-            // InternalRoom.g:2468:1: ( ( rule__AnnotationType__Group__0 ) )
+            // InternalRoom.g:2521:2: ( ( ( rule__AnnotationType__Group__0 ) ) )
+            // InternalRoom.g:2522:1: ( ( rule__AnnotationType__Group__0 ) )
             {
-            // InternalRoom.g:2468:1: ( ( rule__AnnotationType__Group__0 ) )
-            // InternalRoom.g:2469:1: ( rule__AnnotationType__Group__0 )
+            // InternalRoom.g:2522:1: ( ( rule__AnnotationType__Group__0 ) )
+            // InternalRoom.g:2523:1: ( rule__AnnotationType__Group__0 )
             {
              before(grammarAccess.getAnnotationTypeAccess().getGroup()); 
-            // InternalRoom.g:2470:1: ( rule__AnnotationType__Group__0 )
-            // InternalRoom.g:2470:2: rule__AnnotationType__Group__0
+            // InternalRoom.g:2524:1: ( rule__AnnotationType__Group__0 )
+            // InternalRoom.g:2524:2: rule__AnnotationType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group__0();
@@ -6809,11 +6963,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalRoom.g:2482:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ;
+    // InternalRoom.g:2536:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ;
     public final void entryRuleAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalRoom.g:2483:1: ( ruleAnnotationAttribute EOF )
-            // InternalRoom.g:2484:1: ruleAnnotationAttribute EOF
+            // InternalRoom.g:2537:1: ( ruleAnnotationAttribute EOF )
+            // InternalRoom.g:2538:1: ruleAnnotationAttribute EOF
             {
              before(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6839,21 +6993,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationAttribute"
-    // InternalRoom.g:2491:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ;
+    // InternalRoom.g:2545:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ;
     public final void ruleAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2495:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) )
-            // InternalRoom.g:2496:1: ( ( rule__AnnotationAttribute__Alternatives ) )
+            // InternalRoom.g:2549:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) )
+            // InternalRoom.g:2550:1: ( ( rule__AnnotationAttribute__Alternatives ) )
             {
-            // InternalRoom.g:2496:1: ( ( rule__AnnotationAttribute__Alternatives ) )
-            // InternalRoom.g:2497:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalRoom.g:2550:1: ( ( rule__AnnotationAttribute__Alternatives ) )
+            // InternalRoom.g:2551:1: ( rule__AnnotationAttribute__Alternatives )
             {
              before(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); 
-            // InternalRoom.g:2498:1: ( rule__AnnotationAttribute__Alternatives )
-            // InternalRoom.g:2498:2: rule__AnnotationAttribute__Alternatives
+            // InternalRoom.g:2552:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalRoom.g:2552:2: rule__AnnotationAttribute__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationAttribute__Alternatives();
@@ -6886,11 +7040,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalRoom.g:2510:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ;
+    // InternalRoom.g:2564:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ;
     public final void entryRuleSimpleAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalRoom.g:2511:1: ( ruleSimpleAnnotationAttribute EOF )
-            // InternalRoom.g:2512:1: ruleSimpleAnnotationAttribute EOF
+            // InternalRoom.g:2565:1: ( ruleSimpleAnnotationAttribute EOF )
+            // InternalRoom.g:2566:1: ruleSimpleAnnotationAttribute EOF
             {
              before(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6916,21 +7070,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSimpleAnnotationAttribute"
-    // InternalRoom.g:2519:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ;
+    // InternalRoom.g:2573:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ;
     public final void ruleSimpleAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2523:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) )
-            // InternalRoom.g:2524:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2577:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) )
+            // InternalRoom.g:2578:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
             {
-            // InternalRoom.g:2524:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
-            // InternalRoom.g:2525:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2578:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2579:1: ( rule__SimpleAnnotationAttribute__Group__0 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); 
-            // InternalRoom.g:2526:1: ( rule__SimpleAnnotationAttribute__Group__0 )
-            // InternalRoom.g:2526:2: rule__SimpleAnnotationAttribute__Group__0
+            // InternalRoom.g:2580:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2580:2: rule__SimpleAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__0();
@@ -6963,11 +7117,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalRoom.g:2538:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ;
+    // InternalRoom.g:2592:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ;
     public final void entryRuleEnumAnnotationAttribute() throws RecognitionException {
         try {
-            // InternalRoom.g:2539:1: ( ruleEnumAnnotationAttribute EOF )
-            // InternalRoom.g:2540:1: ruleEnumAnnotationAttribute EOF
+            // InternalRoom.g:2593:1: ( ruleEnumAnnotationAttribute EOF )
+            // InternalRoom.g:2594:1: ruleEnumAnnotationAttribute EOF
             {
              before(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6993,21 +7147,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEnumAnnotationAttribute"
-    // InternalRoom.g:2547:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ;
+    // InternalRoom.g:2601:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ;
     public final void ruleEnumAnnotationAttribute() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2551:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) )
-            // InternalRoom.g:2552:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2605:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) )
+            // InternalRoom.g:2606:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
             {
-            // InternalRoom.g:2552:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
-            // InternalRoom.g:2553:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2606:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2607:1: ( rule__EnumAnnotationAttribute__Group__0 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); 
-            // InternalRoom.g:2554:1: ( rule__EnumAnnotationAttribute__Group__0 )
-            // InternalRoom.g:2554:2: rule__EnumAnnotationAttribute__Group__0
+            // InternalRoom.g:2608:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2608:2: rule__EnumAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__0();
@@ -7040,11 +7194,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleImport"
-    // InternalRoom.g:2566:1: entryRuleImport : ruleImport EOF ;
+    // InternalRoom.g:2620:1: entryRuleImport : ruleImport EOF ;
     public final void entryRuleImport() throws RecognitionException {
         try {
-            // InternalRoom.g:2567:1: ( ruleImport EOF )
-            // InternalRoom.g:2568:1: ruleImport EOF
+            // InternalRoom.g:2621:1: ( ruleImport EOF )
+            // InternalRoom.g:2622:1: ruleImport EOF
             {
              before(grammarAccess.getImportRule()); 
             pushFollow(FOLLOW_1);
@@ -7070,21 +7224,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleImport"
-    // InternalRoom.g:2575:1: ruleImport : ( ( rule__Import__Group__0 ) ) ;
+    // InternalRoom.g:2629:1: ruleImport : ( ( rule__Import__Group__0 ) ) ;
     public final void ruleImport() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2579:2: ( ( ( rule__Import__Group__0 ) ) )
-            // InternalRoom.g:2580:1: ( ( rule__Import__Group__0 ) )
+            // InternalRoom.g:2633:2: ( ( ( rule__Import__Group__0 ) ) )
+            // InternalRoom.g:2634:1: ( ( rule__Import__Group__0 ) )
             {
-            // InternalRoom.g:2580:1: ( ( rule__Import__Group__0 ) )
-            // InternalRoom.g:2581:1: ( rule__Import__Group__0 )
+            // InternalRoom.g:2634:1: ( ( rule__Import__Group__0 ) )
+            // InternalRoom.g:2635:1: ( rule__Import__Group__0 )
             {
              before(grammarAccess.getImportAccess().getGroup()); 
-            // InternalRoom.g:2582:1: ( rule__Import__Group__0 )
-            // InternalRoom.g:2582:2: rule__Import__Group__0
+            // InternalRoom.g:2636:1: ( rule__Import__Group__0 )
+            // InternalRoom.g:2636:2: rule__Import__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group__0();
@@ -7117,11 +7271,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalRoom.g:2594:1: entryRuleImportedFQN : ruleImportedFQN EOF ;
+    // InternalRoom.g:2648:1: entryRuleImportedFQN : ruleImportedFQN EOF ;
     public final void entryRuleImportedFQN() throws RecognitionException {
         try {
-            // InternalRoom.g:2595:1: ( ruleImportedFQN EOF )
-            // InternalRoom.g:2596:1: ruleImportedFQN EOF
+            // InternalRoom.g:2649:1: ( ruleImportedFQN EOF )
+            // InternalRoom.g:2650:1: ruleImportedFQN EOF
             {
              before(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -7147,21 +7301,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleImportedFQN"
-    // InternalRoom.g:2603:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ;
+    // InternalRoom.g:2657:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ;
     public final void ruleImportedFQN() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2607:2: ( ( ( rule__ImportedFQN__Group__0 ) ) )
-            // InternalRoom.g:2608:1: ( ( rule__ImportedFQN__Group__0 ) )
+            // InternalRoom.g:2661:2: ( ( ( rule__ImportedFQN__Group__0 ) ) )
+            // InternalRoom.g:2662:1: ( ( rule__ImportedFQN__Group__0 ) )
             {
-            // InternalRoom.g:2608:1: ( ( rule__ImportedFQN__Group__0 ) )
-            // InternalRoom.g:2609:1: ( rule__ImportedFQN__Group__0 )
+            // InternalRoom.g:2662:1: ( ( rule__ImportedFQN__Group__0 ) )
+            // InternalRoom.g:2663:1: ( rule__ImportedFQN__Group__0 )
             {
              before(grammarAccess.getImportedFQNAccess().getGroup()); 
-            // InternalRoom.g:2610:1: ( rule__ImportedFQN__Group__0 )
-            // InternalRoom.g:2610:2: rule__ImportedFQN__Group__0
+            // InternalRoom.g:2664:1: ( rule__ImportedFQN__Group__0 )
+            // InternalRoom.g:2664:2: rule__ImportedFQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__0();
@@ -7194,11 +7348,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalRoom.g:2622:1: entryRuleDocumentation : ruleDocumentation EOF ;
+    // InternalRoom.g:2676:1: entryRuleDocumentation : ruleDocumentation EOF ;
     public final void entryRuleDocumentation() throws RecognitionException {
         try {
-            // InternalRoom.g:2623:1: ( ruleDocumentation EOF )
-            // InternalRoom.g:2624:1: ruleDocumentation EOF
+            // InternalRoom.g:2677:1: ( ruleDocumentation EOF )
+            // InternalRoom.g:2678:1: ruleDocumentation EOF
             {
              before(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -7224,21 +7378,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDocumentation"
-    // InternalRoom.g:2631:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ;
+    // InternalRoom.g:2685:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ;
     public final void ruleDocumentation() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2635:2: ( ( ( rule__Documentation__Group__0 ) ) )
-            // InternalRoom.g:2636:1: ( ( rule__Documentation__Group__0 ) )
+            // InternalRoom.g:2689:2: ( ( ( rule__Documentation__Group__0 ) ) )
+            // InternalRoom.g:2690:1: ( ( rule__Documentation__Group__0 ) )
             {
-            // InternalRoom.g:2636:1: ( ( rule__Documentation__Group__0 ) )
-            // InternalRoom.g:2637:1: ( rule__Documentation__Group__0 )
+            // InternalRoom.g:2690:1: ( ( rule__Documentation__Group__0 ) )
+            // InternalRoom.g:2691:1: ( rule__Documentation__Group__0 )
             {
              before(grammarAccess.getDocumentationAccess().getGroup()); 
-            // InternalRoom.g:2638:1: ( rule__Documentation__Group__0 )
-            // InternalRoom.g:2638:2: rule__Documentation__Group__0
+            // InternalRoom.g:2692:1: ( rule__Documentation__Group__0 )
+            // InternalRoom.g:2692:2: rule__Documentation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__0();
@@ -7271,11 +7425,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalRoom.g:2654:1: entryRuleLiteral : ruleLiteral EOF ;
+    // InternalRoom.g:2708:1: entryRuleLiteral : ruleLiteral EOF ;
     public final void entryRuleLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2655:1: ( ruleLiteral EOF )
-            // InternalRoom.g:2656:1: ruleLiteral EOF
+            // InternalRoom.g:2709:1: ( ruleLiteral EOF )
+            // InternalRoom.g:2710:1: ruleLiteral EOF
             {
              before(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7301,21 +7455,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteral"
-    // InternalRoom.g:2663:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
+    // InternalRoom.g:2717:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
     public final void ruleLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2667:2: ( ( ( rule__Literal__Alternatives ) ) )
-            // InternalRoom.g:2668:1: ( ( rule__Literal__Alternatives ) )
+            // InternalRoom.g:2721:2: ( ( ( rule__Literal__Alternatives ) ) )
+            // InternalRoom.g:2722:1: ( ( rule__Literal__Alternatives ) )
             {
-            // InternalRoom.g:2668:1: ( ( rule__Literal__Alternatives ) )
-            // InternalRoom.g:2669:1: ( rule__Literal__Alternatives )
+            // InternalRoom.g:2722:1: ( ( rule__Literal__Alternatives ) )
+            // InternalRoom.g:2723:1: ( rule__Literal__Alternatives )
             {
              before(grammarAccess.getLiteralAccess().getAlternatives()); 
-            // InternalRoom.g:2670:1: ( rule__Literal__Alternatives )
-            // InternalRoom.g:2670:2: rule__Literal__Alternatives
+            // InternalRoom.g:2724:1: ( rule__Literal__Alternatives )
+            // InternalRoom.g:2724:2: rule__Literal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Literal__Alternatives();
@@ -7348,11 +7502,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalRoom.g:2682:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ;
+    // InternalRoom.g:2736:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ;
     public final void entryRuleBooleanLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2683:1: ( ruleBooleanLiteral EOF )
-            // InternalRoom.g:2684:1: ruleBooleanLiteral EOF
+            // InternalRoom.g:2737:1: ( ruleBooleanLiteral EOF )
+            // InternalRoom.g:2738:1: ruleBooleanLiteral EOF
             {
              before(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7378,21 +7532,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleBooleanLiteral"
-    // InternalRoom.g:2691:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2745:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ;
     public final void ruleBooleanLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2695:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) )
-            // InternalRoom.g:2696:1: ( ( rule__BooleanLiteral__Group__0 ) )
+            // InternalRoom.g:2749:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) )
+            // InternalRoom.g:2750:1: ( ( rule__BooleanLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2696:1: ( ( rule__BooleanLiteral__Group__0 ) )
-            // InternalRoom.g:2697:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalRoom.g:2750:1: ( ( rule__BooleanLiteral__Group__0 ) )
+            // InternalRoom.g:2751:1: ( rule__BooleanLiteral__Group__0 )
             {
              before(grammarAccess.getBooleanLiteralAccess().getGroup()); 
-            // InternalRoom.g:2698:1: ( rule__BooleanLiteral__Group__0 )
-            // InternalRoom.g:2698:2: rule__BooleanLiteral__Group__0
+            // InternalRoom.g:2752:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalRoom.g:2752:2: rule__BooleanLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__0();
@@ -7425,11 +7579,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalRoom.g:2710:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
+    // InternalRoom.g:2764:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
     public final void entryRuleNumberLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2711:1: ( ruleNumberLiteral EOF )
-            // InternalRoom.g:2712:1: ruleNumberLiteral EOF
+            // InternalRoom.g:2765:1: ( ruleNumberLiteral EOF )
+            // InternalRoom.g:2766:1: ruleNumberLiteral EOF
             {
              before(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7455,21 +7609,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNumberLiteral"
-    // InternalRoom.g:2719:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ;
+    // InternalRoom.g:2773:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ;
     public final void ruleNumberLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2723:2: ( ( ( rule__NumberLiteral__Alternatives ) ) )
-            // InternalRoom.g:2724:1: ( ( rule__NumberLiteral__Alternatives ) )
+            // InternalRoom.g:2777:2: ( ( ( rule__NumberLiteral__Alternatives ) ) )
+            // InternalRoom.g:2778:1: ( ( rule__NumberLiteral__Alternatives ) )
             {
-            // InternalRoom.g:2724:1: ( ( rule__NumberLiteral__Alternatives ) )
-            // InternalRoom.g:2725:1: ( rule__NumberLiteral__Alternatives )
+            // InternalRoom.g:2778:1: ( ( rule__NumberLiteral__Alternatives ) )
+            // InternalRoom.g:2779:1: ( rule__NumberLiteral__Alternatives )
             {
              before(grammarAccess.getNumberLiteralAccess().getAlternatives()); 
-            // InternalRoom.g:2726:1: ( rule__NumberLiteral__Alternatives )
-            // InternalRoom.g:2726:2: rule__NumberLiteral__Alternatives
+            // InternalRoom.g:2780:1: ( rule__NumberLiteral__Alternatives )
+            // InternalRoom.g:2780:2: rule__NumberLiteral__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NumberLiteral__Alternatives();
@@ -7502,11 +7656,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalRoom.g:2738:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
+    // InternalRoom.g:2792:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
     public final void entryRuleRealLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2739:1: ( ruleRealLiteral EOF )
-            // InternalRoom.g:2740:1: ruleRealLiteral EOF
+            // InternalRoom.g:2793:1: ( ruleRealLiteral EOF )
+            // InternalRoom.g:2794:1: ruleRealLiteral EOF
             {
              before(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7532,21 +7686,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRealLiteral"
-    // InternalRoom.g:2747:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2801:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ;
     public final void ruleRealLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2751:2: ( ( ( rule__RealLiteral__Group__0 ) ) )
-            // InternalRoom.g:2752:1: ( ( rule__RealLiteral__Group__0 ) )
+            // InternalRoom.g:2805:2: ( ( ( rule__RealLiteral__Group__0 ) ) )
+            // InternalRoom.g:2806:1: ( ( rule__RealLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2752:1: ( ( rule__RealLiteral__Group__0 ) )
-            // InternalRoom.g:2753:1: ( rule__RealLiteral__Group__0 )
+            // InternalRoom.g:2806:1: ( ( rule__RealLiteral__Group__0 ) )
+            // InternalRoom.g:2807:1: ( rule__RealLiteral__Group__0 )
             {
              before(grammarAccess.getRealLiteralAccess().getGroup()); 
-            // InternalRoom.g:2754:1: ( rule__RealLiteral__Group__0 )
-            // InternalRoom.g:2754:2: rule__RealLiteral__Group__0
+            // InternalRoom.g:2808:1: ( rule__RealLiteral__Group__0 )
+            // InternalRoom.g:2808:2: rule__RealLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__0();
@@ -7579,11 +7733,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalRoom.g:2766:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
+    // InternalRoom.g:2820:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
     public final void entryRuleIntLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2767:1: ( ruleIntLiteral EOF )
-            // InternalRoom.g:2768:1: ruleIntLiteral EOF
+            // InternalRoom.g:2821:1: ( ruleIntLiteral EOF )
+            // InternalRoom.g:2822:1: ruleIntLiteral EOF
             {
              before(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7609,21 +7763,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleIntLiteral"
-    // InternalRoom.g:2775:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2829:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ;
     public final void ruleIntLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2779:2: ( ( ( rule__IntLiteral__Group__0 ) ) )
-            // InternalRoom.g:2780:1: ( ( rule__IntLiteral__Group__0 ) )
+            // InternalRoom.g:2833:2: ( ( ( rule__IntLiteral__Group__0 ) ) )
+            // InternalRoom.g:2834:1: ( ( rule__IntLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2780:1: ( ( rule__IntLiteral__Group__0 ) )
-            // InternalRoom.g:2781:1: ( rule__IntLiteral__Group__0 )
+            // InternalRoom.g:2834:1: ( ( rule__IntLiteral__Group__0 ) )
+            // InternalRoom.g:2835:1: ( rule__IntLiteral__Group__0 )
             {
              before(grammarAccess.getIntLiteralAccess().getGroup()); 
-            // InternalRoom.g:2782:1: ( rule__IntLiteral__Group__0 )
-            // InternalRoom.g:2782:2: rule__IntLiteral__Group__0
+            // InternalRoom.g:2836:1: ( rule__IntLiteral__Group__0 )
+            // InternalRoom.g:2836:2: rule__IntLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__0();
@@ -7656,11 +7810,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalRoom.g:2794:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
+    // InternalRoom.g:2848:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
     public final void entryRuleStringLiteral() throws RecognitionException {
         try {
-            // InternalRoom.g:2795:1: ( ruleStringLiteral EOF )
-            // InternalRoom.g:2796:1: ruleStringLiteral EOF
+            // InternalRoom.g:2849:1: ( ruleStringLiteral EOF )
+            // InternalRoom.g:2850:1: ruleStringLiteral EOF
             {
              before(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7686,21 +7840,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStringLiteral"
-    // InternalRoom.g:2803:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2857:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
     public final void ruleStringLiteral() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2807:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
-            // InternalRoom.g:2808:1: ( ( rule__StringLiteral__Group__0 ) )
+            // InternalRoom.g:2861:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
+            // InternalRoom.g:2862:1: ( ( rule__StringLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2808:1: ( ( rule__StringLiteral__Group__0 ) )
-            // InternalRoom.g:2809:1: ( rule__StringLiteral__Group__0 )
+            // InternalRoom.g:2862:1: ( ( rule__StringLiteral__Group__0 ) )
+            // InternalRoom.g:2863:1: ( rule__StringLiteral__Group__0 )
             {
              before(grammarAccess.getStringLiteralAccess().getGroup()); 
-            // InternalRoom.g:2810:1: ( rule__StringLiteral__Group__0 )
-            // InternalRoom.g:2810:2: rule__StringLiteral__Group__0
+            // InternalRoom.g:2864:1: ( rule__StringLiteral__Group__0 )
+            // InternalRoom.g:2864:2: rule__StringLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__0();
@@ -7733,11 +7887,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalRoom.g:2822:1: entryRuleInteger : ruleInteger EOF ;
+    // InternalRoom.g:2876:1: entryRuleInteger : ruleInteger EOF ;
     public final void entryRuleInteger() throws RecognitionException {
         try {
-            // InternalRoom.g:2823:1: ( ruleInteger EOF )
-            // InternalRoom.g:2824:1: ruleInteger EOF
+            // InternalRoom.g:2877:1: ( ruleInteger EOF )
+            // InternalRoom.g:2878:1: ruleInteger EOF
             {
              before(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -7763,21 +7917,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInteger"
-    // InternalRoom.g:2831:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ;
+    // InternalRoom.g:2885:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ;
     public final void ruleInteger() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2835:2: ( ( ( rule__Integer__Alternatives ) ) )
-            // InternalRoom.g:2836:1: ( ( rule__Integer__Alternatives ) )
+            // InternalRoom.g:2889:2: ( ( ( rule__Integer__Alternatives ) ) )
+            // InternalRoom.g:2890:1: ( ( rule__Integer__Alternatives ) )
             {
-            // InternalRoom.g:2836:1: ( ( rule__Integer__Alternatives ) )
-            // InternalRoom.g:2837:1: ( rule__Integer__Alternatives )
+            // InternalRoom.g:2890:1: ( ( rule__Integer__Alternatives ) )
+            // InternalRoom.g:2891:1: ( rule__Integer__Alternatives )
             {
              before(grammarAccess.getIntegerAccess().getAlternatives()); 
-            // InternalRoom.g:2838:1: ( rule__Integer__Alternatives )
-            // InternalRoom.g:2838:2: rule__Integer__Alternatives
+            // InternalRoom.g:2892:1: ( rule__Integer__Alternatives )
+            // InternalRoom.g:2892:2: rule__Integer__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Alternatives();
@@ -7810,11 +7964,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalRoom.g:2850:1: entryRuleReal : ruleReal EOF ;
+    // InternalRoom.g:2904:1: entryRuleReal : ruleReal EOF ;
     public final void entryRuleReal() throws RecognitionException {
         try {
-            // InternalRoom.g:2851:1: ( ruleReal EOF )
-            // InternalRoom.g:2852:1: ruleReal EOF
+            // InternalRoom.g:2905:1: ( ruleReal EOF )
+            // InternalRoom.g:2906:1: ruleReal EOF
             {
              before(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -7840,21 +7994,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleReal"
-    // InternalRoom.g:2859:1: ruleReal : ( ( rule__Real__Alternatives ) ) ;
+    // InternalRoom.g:2913:1: ruleReal : ( ( rule__Real__Alternatives ) ) ;
     public final void ruleReal() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2863:2: ( ( ( rule__Real__Alternatives ) ) )
-            // InternalRoom.g:2864:1: ( ( rule__Real__Alternatives ) )
+            // InternalRoom.g:2917:2: ( ( ( rule__Real__Alternatives ) ) )
+            // InternalRoom.g:2918:1: ( ( rule__Real__Alternatives ) )
             {
-            // InternalRoom.g:2864:1: ( ( rule__Real__Alternatives ) )
-            // InternalRoom.g:2865:1: ( rule__Real__Alternatives )
+            // InternalRoom.g:2918:1: ( ( rule__Real__Alternatives ) )
+            // InternalRoom.g:2919:1: ( rule__Real__Alternatives )
             {
              before(grammarAccess.getRealAccess().getAlternatives()); 
-            // InternalRoom.g:2866:1: ( rule__Real__Alternatives )
-            // InternalRoom.g:2866:2: rule__Real__Alternatives
+            // InternalRoom.g:2920:1: ( rule__Real__Alternatives )
+            // InternalRoom.g:2920:2: rule__Real__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Real__Alternatives();
@@ -7887,14 +8041,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalRoom.g:2878:1: entryRuleDecimal : ruleDecimal EOF ;
+    // InternalRoom.g:2932:1: entryRuleDecimal : ruleDecimal EOF ;
     public final void entryRuleDecimal() throws RecognitionException {
 
         	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
 
         try {
-            // InternalRoom.g:2882:1: ( ruleDecimal EOF )
-            // InternalRoom.g:2883:1: ruleDecimal EOF
+            // InternalRoom.g:2936:1: ( ruleDecimal EOF )
+            // InternalRoom.g:2937:1: ruleDecimal EOF
             {
              before(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -7923,22 +8077,22 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimal"
-    // InternalRoom.g:2893:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ;
+    // InternalRoom.g:2947:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ;
     public final void ruleDecimal() throws RecognitionException {
 
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2898:2: ( ( ( rule__Decimal__Group__0 ) ) )
-            // InternalRoom.g:2899:1: ( ( rule__Decimal__Group__0 ) )
+            // InternalRoom.g:2952:2: ( ( ( rule__Decimal__Group__0 ) ) )
+            // InternalRoom.g:2953:1: ( ( rule__Decimal__Group__0 ) )
             {
-            // InternalRoom.g:2899:1: ( ( rule__Decimal__Group__0 ) )
-            // InternalRoom.g:2900:1: ( rule__Decimal__Group__0 )
+            // InternalRoom.g:2953:1: ( ( rule__Decimal__Group__0 ) )
+            // InternalRoom.g:2954:1: ( rule__Decimal__Group__0 )
             {
              before(grammarAccess.getDecimalAccess().getGroup()); 
-            // InternalRoom.g:2901:1: ( rule__Decimal__Group__0 )
-            // InternalRoom.g:2901:2: rule__Decimal__Group__0
+            // InternalRoom.g:2955:1: ( rule__Decimal__Group__0 )
+            // InternalRoom.g:2955:2: rule__Decimal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__0();
@@ -7972,14 +8126,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalRoom.g:2914:1: entryRuleDecimalExp : ruleDecimalExp EOF ;
+    // InternalRoom.g:2968:1: entryRuleDecimalExp : ruleDecimalExp EOF ;
     public final void entryRuleDecimalExp() throws RecognitionException {
 
         	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
 
         try {
-            // InternalRoom.g:2918:1: ( ruleDecimalExp EOF )
-            // InternalRoom.g:2919:1: ruleDecimalExp EOF
+            // InternalRoom.g:2972:1: ( ruleDecimalExp EOF )
+            // InternalRoom.g:2973:1: ruleDecimalExp EOF
             {
              before(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -8008,22 +8162,22 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimalExp"
-    // InternalRoom.g:2929:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ;
+    // InternalRoom.g:2983:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ;
     public final void ruleDecimalExp() throws RecognitionException {
 
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2934:2: ( ( ( rule__DecimalExp__Group__0 ) ) )
-            // InternalRoom.g:2935:1: ( ( rule__DecimalExp__Group__0 ) )
+            // InternalRoom.g:2988:2: ( ( ( rule__DecimalExp__Group__0 ) ) )
+            // InternalRoom.g:2989:1: ( ( rule__DecimalExp__Group__0 ) )
             {
-            // InternalRoom.g:2935:1: ( ( rule__DecimalExp__Group__0 ) )
-            // InternalRoom.g:2936:1: ( rule__DecimalExp__Group__0 )
+            // InternalRoom.g:2989:1: ( ( rule__DecimalExp__Group__0 ) )
+            // InternalRoom.g:2990:1: ( rule__DecimalExp__Group__0 )
             {
              before(grammarAccess.getDecimalExpAccess().getGroup()); 
-            // InternalRoom.g:2937:1: ( rule__DecimalExp__Group__0 )
-            // InternalRoom.g:2937:2: rule__DecimalExp__Group__0
+            // InternalRoom.g:2991:1: ( rule__DecimalExp__Group__0 )
+            // InternalRoom.g:2991:2: rule__DecimalExp__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__0();
@@ -8057,11 +8211,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalRoom.g:2950:1: entryRuleFQN : ruleFQN EOF ;
+    // InternalRoom.g:3004:1: entryRuleFQN : ruleFQN EOF ;
     public final void entryRuleFQN() throws RecognitionException {
         try {
-            // InternalRoom.g:2951:1: ( ruleFQN EOF )
-            // InternalRoom.g:2952:1: ruleFQN EOF
+            // InternalRoom.g:3005:1: ( ruleFQN EOF )
+            // InternalRoom.g:3006:1: ruleFQN EOF
             {
              before(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -8087,21 +8241,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleFQN"
-    // InternalRoom.g:2959:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ;
+    // InternalRoom.g:3013:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ;
     public final void ruleFQN() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2963:2: ( ( ( rule__FQN__Group__0 ) ) )
-            // InternalRoom.g:2964:1: ( ( rule__FQN__Group__0 ) )
+            // InternalRoom.g:3017:2: ( ( ( rule__FQN__Group__0 ) ) )
+            // InternalRoom.g:3018:1: ( ( rule__FQN__Group__0 ) )
             {
-            // InternalRoom.g:2964:1: ( ( rule__FQN__Group__0 ) )
-            // InternalRoom.g:2965:1: ( rule__FQN__Group__0 )
+            // InternalRoom.g:3018:1: ( ( rule__FQN__Group__0 ) )
+            // InternalRoom.g:3019:1: ( rule__FQN__Group__0 )
             {
              before(grammarAccess.getFQNAccess().getGroup()); 
-            // InternalRoom.g:2966:1: ( rule__FQN__Group__0 )
-            // InternalRoom.g:2966:2: rule__FQN__Group__0
+            // InternalRoom.g:3020:1: ( rule__FQN__Group__0 )
+            // InternalRoom.g:3020:2: rule__FQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__0();
@@ -8134,21 +8288,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCommunicationType"
-    // InternalRoom.g:2979:1: ruleCommunicationType : ( ( rule__CommunicationType__Alternatives ) ) ;
+    // InternalRoom.g:3033:1: ruleCommunicationType : ( ( rule__CommunicationType__Alternatives ) ) ;
     public final void ruleCommunicationType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:2983:1: ( ( ( rule__CommunicationType__Alternatives ) ) )
-            // InternalRoom.g:2984:1: ( ( rule__CommunicationType__Alternatives ) )
+            // InternalRoom.g:3037:1: ( ( ( rule__CommunicationType__Alternatives ) ) )
+            // InternalRoom.g:3038:1: ( ( rule__CommunicationType__Alternatives ) )
             {
-            // InternalRoom.g:2984:1: ( ( rule__CommunicationType__Alternatives ) )
-            // InternalRoom.g:2985:1: ( rule__CommunicationType__Alternatives )
+            // InternalRoom.g:3038:1: ( ( rule__CommunicationType__Alternatives ) )
+            // InternalRoom.g:3039:1: ( rule__CommunicationType__Alternatives )
             {
              before(grammarAccess.getCommunicationTypeAccess().getAlternatives()); 
-            // InternalRoom.g:2986:1: ( rule__CommunicationType__Alternatives )
-            // InternalRoom.g:2986:2: rule__CommunicationType__Alternatives
+            // InternalRoom.g:3040:1: ( rule__CommunicationType__Alternatives )
+            // InternalRoom.g:3040:2: rule__CommunicationType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__CommunicationType__Alternatives();
@@ -8181,21 +8335,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleReferenceType"
-    // InternalRoom.g:2998:1: ruleReferenceType : ( ( rule__ReferenceType__Alternatives ) ) ;
+    // InternalRoom.g:3052:1: ruleReferenceType : ( ( rule__ReferenceType__Alternatives ) ) ;
     public final void ruleReferenceType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3002:1: ( ( ( rule__ReferenceType__Alternatives ) ) )
-            // InternalRoom.g:3003:1: ( ( rule__ReferenceType__Alternatives ) )
+            // InternalRoom.g:3056:1: ( ( ( rule__ReferenceType__Alternatives ) ) )
+            // InternalRoom.g:3057:1: ( ( rule__ReferenceType__Alternatives ) )
             {
-            // InternalRoom.g:3003:1: ( ( rule__ReferenceType__Alternatives ) )
-            // InternalRoom.g:3004:1: ( rule__ReferenceType__Alternatives )
+            // InternalRoom.g:3057:1: ( ( rule__ReferenceType__Alternatives ) )
+            // InternalRoom.g:3058:1: ( rule__ReferenceType__Alternatives )
             {
              before(grammarAccess.getReferenceTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3005:1: ( rule__ReferenceType__Alternatives )
-            // InternalRoom.g:3005:2: rule__ReferenceType__Alternatives
+            // InternalRoom.g:3059:1: ( rule__ReferenceType__Alternatives )
+            // InternalRoom.g:3059:2: rule__ReferenceType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ReferenceType__Alternatives();
@@ -8228,21 +8382,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleComponentCommunicationType"
-    // InternalRoom.g:3019:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ;
+    // InternalRoom.g:3073:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ;
     public final void ruleComponentCommunicationType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3023:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) )
-            // InternalRoom.g:3024:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
+            // InternalRoom.g:3077:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) )
+            // InternalRoom.g:3078:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
             {
-            // InternalRoom.g:3024:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
-            // InternalRoom.g:3025:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalRoom.g:3078:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
+            // InternalRoom.g:3079:1: ( rule__ComponentCommunicationType__Alternatives )
             {
              before(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3026:1: ( rule__ComponentCommunicationType__Alternatives )
-            // InternalRoom.g:3026:2: rule__ComponentCommunicationType__Alternatives
+            // InternalRoom.g:3080:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalRoom.g:3080:2: rule__ComponentCommunicationType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ComponentCommunicationType__Alternatives();
@@ -8275,21 +8429,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteralType"
-    // InternalRoom.g:3038:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ;
+    // InternalRoom.g:3092:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ;
     public final void ruleLiteralType() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3042:1: ( ( ( rule__LiteralType__Alternatives ) ) )
-            // InternalRoom.g:3043:1: ( ( rule__LiteralType__Alternatives ) )
+            // InternalRoom.g:3096:1: ( ( ( rule__LiteralType__Alternatives ) ) )
+            // InternalRoom.g:3097:1: ( ( rule__LiteralType__Alternatives ) )
             {
-            // InternalRoom.g:3043:1: ( ( rule__LiteralType__Alternatives ) )
-            // InternalRoom.g:3044:1: ( rule__LiteralType__Alternatives )
+            // InternalRoom.g:3097:1: ( ( rule__LiteralType__Alternatives ) )
+            // InternalRoom.g:3098:1: ( rule__LiteralType__Alternatives )
             {
              before(grammarAccess.getLiteralTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3045:1: ( rule__LiteralType__Alternatives )
-            // InternalRoom.g:3045:2: rule__LiteralType__Alternatives
+            // InternalRoom.g:3099:1: ( rule__LiteralType__Alternatives )
+            // InternalRoom.g:3099:2: rule__LiteralType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__LiteralType__Alternatives();
@@ -8322,25 +8476,25 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Alternatives_5"
-    // InternalRoom.g:3056:1: rule__RoomModel__Alternatives_5 : ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) );
+    // InternalRoom.g:3110:1: rule__RoomModel__Alternatives_5 : ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) );
     public final void rule__RoomModel__Alternatives_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3060:1: ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) )
+            // InternalRoom.g:3114:1: ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) )
             int alt1=9;
             alt1 = dfa1.predict(input);
             switch (alt1) {
                 case 1 :
-                    // InternalRoom.g:3061:1: ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) )
+                    // InternalRoom.g:3115:1: ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) )
                     {
-                    // InternalRoom.g:3061:1: ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) )
-                    // InternalRoom.g:3062:1: ( rule__RoomModel__PrimitiveTypesAssignment_5_0 )
+                    // InternalRoom.g:3115:1: ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) )
+                    // InternalRoom.g:3116:1: ( rule__RoomModel__PrimitiveTypesAssignment_5_0 )
                     {
                      before(grammarAccess.getRoomModelAccess().getPrimitiveTypesAssignment_5_0()); 
-                    // InternalRoom.g:3063:1: ( rule__RoomModel__PrimitiveTypesAssignment_5_0 )
-                    // InternalRoom.g:3063:2: rule__RoomModel__PrimitiveTypesAssignment_5_0
+                    // InternalRoom.g:3117:1: ( rule__RoomModel__PrimitiveTypesAssignment_5_0 )
+                    // InternalRoom.g:3117:2: rule__RoomModel__PrimitiveTypesAssignment_5_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__PrimitiveTypesAssignment_5_0();
@@ -8358,14 +8512,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3067:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
+                    // InternalRoom.g:3121:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
                     {
-                    // InternalRoom.g:3067:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
-                    // InternalRoom.g:3068:1: ( rule__RoomModel__EnumerationTypesAssignment_5_1 )
+                    // InternalRoom.g:3121:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
+                    // InternalRoom.g:3122:1: ( rule__RoomModel__EnumerationTypesAssignment_5_1 )
                     {
                      before(grammarAccess.getRoomModelAccess().getEnumerationTypesAssignment_5_1()); 
-                    // InternalRoom.g:3069:1: ( rule__RoomModel__EnumerationTypesAssignment_5_1 )
-                    // InternalRoom.g:3069:2: rule__RoomModel__EnumerationTypesAssignment_5_1
+                    // InternalRoom.g:3123:1: ( rule__RoomModel__EnumerationTypesAssignment_5_1 )
+                    // InternalRoom.g:3123:2: rule__RoomModel__EnumerationTypesAssignment_5_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__EnumerationTypesAssignment_5_1();
@@ -8383,14 +8537,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3073:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
+                    // InternalRoom.g:3127:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
                     {
-                    // InternalRoom.g:3073:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
-                    // InternalRoom.g:3074:1: ( rule__RoomModel__ExternalTypesAssignment_5_2 )
+                    // InternalRoom.g:3127:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
+                    // InternalRoom.g:3128:1: ( rule__RoomModel__ExternalTypesAssignment_5_2 )
                     {
                      before(grammarAccess.getRoomModelAccess().getExternalTypesAssignment_5_2()); 
-                    // InternalRoom.g:3075:1: ( rule__RoomModel__ExternalTypesAssignment_5_2 )
-                    // InternalRoom.g:3075:2: rule__RoomModel__ExternalTypesAssignment_5_2
+                    // InternalRoom.g:3129:1: ( rule__RoomModel__ExternalTypesAssignment_5_2 )
+                    // InternalRoom.g:3129:2: rule__RoomModel__ExternalTypesAssignment_5_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ExternalTypesAssignment_5_2();
@@ -8408,14 +8562,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3079:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
+                    // InternalRoom.g:3133:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
                     {
-                    // InternalRoom.g:3079:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
-                    // InternalRoom.g:3080:1: ( rule__RoomModel__DataClassesAssignment_5_3 )
+                    // InternalRoom.g:3133:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
+                    // InternalRoom.g:3134:1: ( rule__RoomModel__DataClassesAssignment_5_3 )
                     {
                      before(grammarAccess.getRoomModelAccess().getDataClassesAssignment_5_3()); 
-                    // InternalRoom.g:3081:1: ( rule__RoomModel__DataClassesAssignment_5_3 )
-                    // InternalRoom.g:3081:2: rule__RoomModel__DataClassesAssignment_5_3
+                    // InternalRoom.g:3135:1: ( rule__RoomModel__DataClassesAssignment_5_3 )
+                    // InternalRoom.g:3135:2: rule__RoomModel__DataClassesAssignment_5_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__DataClassesAssignment_5_3();
@@ -8433,14 +8587,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3085:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
+                    // InternalRoom.g:3139:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
                     {
-                    // InternalRoom.g:3085:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
-                    // InternalRoom.g:3086:1: ( rule__RoomModel__ProtocolClassesAssignment_5_4 )
+                    // InternalRoom.g:3139:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
+                    // InternalRoom.g:3140:1: ( rule__RoomModel__ProtocolClassesAssignment_5_4 )
                     {
                      before(grammarAccess.getRoomModelAccess().getProtocolClassesAssignment_5_4()); 
-                    // InternalRoom.g:3087:1: ( rule__RoomModel__ProtocolClassesAssignment_5_4 )
-                    // InternalRoom.g:3087:2: rule__RoomModel__ProtocolClassesAssignment_5_4
+                    // InternalRoom.g:3141:1: ( rule__RoomModel__ProtocolClassesAssignment_5_4 )
+                    // InternalRoom.g:3141:2: rule__RoomModel__ProtocolClassesAssignment_5_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ProtocolClassesAssignment_5_4();
@@ -8458,14 +8612,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3091:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
+                    // InternalRoom.g:3145:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
                     {
-                    // InternalRoom.g:3091:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
-                    // InternalRoom.g:3092:1: ( rule__RoomModel__ActorClassesAssignment_5_5 )
+                    // InternalRoom.g:3145:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
+                    // InternalRoom.g:3146:1: ( rule__RoomModel__ActorClassesAssignment_5_5 )
                     {
                      before(grammarAccess.getRoomModelAccess().getActorClassesAssignment_5_5()); 
-                    // InternalRoom.g:3093:1: ( rule__RoomModel__ActorClassesAssignment_5_5 )
-                    // InternalRoom.g:3093:2: rule__RoomModel__ActorClassesAssignment_5_5
+                    // InternalRoom.g:3147:1: ( rule__RoomModel__ActorClassesAssignment_5_5 )
+                    // InternalRoom.g:3147:2: rule__RoomModel__ActorClassesAssignment_5_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ActorClassesAssignment_5_5();
@@ -8483,14 +8637,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3097:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
+                    // InternalRoom.g:3151:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
                     {
-                    // InternalRoom.g:3097:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
-                    // InternalRoom.g:3098:1: ( rule__RoomModel__SubSystemClassesAssignment_5_6 )
+                    // InternalRoom.g:3151:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
+                    // InternalRoom.g:3152:1: ( rule__RoomModel__SubSystemClassesAssignment_5_6 )
                     {
                      before(grammarAccess.getRoomModelAccess().getSubSystemClassesAssignment_5_6()); 
-                    // InternalRoom.g:3099:1: ( rule__RoomModel__SubSystemClassesAssignment_5_6 )
-                    // InternalRoom.g:3099:2: rule__RoomModel__SubSystemClassesAssignment_5_6
+                    // InternalRoom.g:3153:1: ( rule__RoomModel__SubSystemClassesAssignment_5_6 )
+                    // InternalRoom.g:3153:2: rule__RoomModel__SubSystemClassesAssignment_5_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__SubSystemClassesAssignment_5_6();
@@ -8508,14 +8662,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3103:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
+                    // InternalRoom.g:3157:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
                     {
-                    // InternalRoom.g:3103:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
-                    // InternalRoom.g:3104:1: ( rule__RoomModel__SystemsAssignment_5_7 )
+                    // InternalRoom.g:3157:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
+                    // InternalRoom.g:3158:1: ( rule__RoomModel__SystemsAssignment_5_7 )
                     {
                      before(grammarAccess.getRoomModelAccess().getSystemsAssignment_5_7()); 
-                    // InternalRoom.g:3105:1: ( rule__RoomModel__SystemsAssignment_5_7 )
-                    // InternalRoom.g:3105:2: rule__RoomModel__SystemsAssignment_5_7
+                    // InternalRoom.g:3159:1: ( rule__RoomModel__SystemsAssignment_5_7 )
+                    // InternalRoom.g:3159:2: rule__RoomModel__SystemsAssignment_5_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__SystemsAssignment_5_7();
@@ -8533,14 +8687,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 9 :
-                    // InternalRoom.g:3109:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
+                    // InternalRoom.g:3163:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
                     {
-                    // InternalRoom.g:3109:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
-                    // InternalRoom.g:3110:1: ( rule__RoomModel__AnnotationTypesAssignment_5_8 )
+                    // InternalRoom.g:3163:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
+                    // InternalRoom.g:3164:1: ( rule__RoomModel__AnnotationTypesAssignment_5_8 )
                     {
                      before(grammarAccess.getRoomModelAccess().getAnnotationTypesAssignment_5_8()); 
-                    // InternalRoom.g:3111:1: ( rule__RoomModel__AnnotationTypesAssignment_5_8 )
-                    // InternalRoom.g:3111:2: rule__RoomModel__AnnotationTypesAssignment_5_8
+                    // InternalRoom.g:3165:1: ( rule__RoomModel__AnnotationTypesAssignment_5_8 )
+                    // InternalRoom.g:3165:2: rule__RoomModel__AnnotationTypesAssignment_5_8
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__AnnotationTypesAssignment_5_8();
@@ -8575,13 +8729,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StructureClass__Alternatives"
-    // InternalRoom.g:3121:1: rule__StructureClass__Alternatives : ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) );
+    // InternalRoom.g:3175:1: rule__StructureClass__Alternatives : ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) );
     public final void rule__StructureClass__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3125:1: ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) )
+            // InternalRoom.g:3179:1: ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) )
             int alt2=2;
             int LA2_0 = input.LA(1);
 
@@ -8599,10 +8753,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt2) {
                 case 1 :
-                    // InternalRoom.g:3126:1: ( ruleActorContainerClass )
+                    // InternalRoom.g:3180:1: ( ruleActorContainerClass )
                     {
-                    // InternalRoom.g:3126:1: ( ruleActorContainerClass )
-                    // InternalRoom.g:3127:1: ruleActorContainerClass
+                    // InternalRoom.g:3180:1: ( ruleActorContainerClass )
+                    // InternalRoom.g:3181:1: ruleActorContainerClass
                     {
                      before(grammarAccess.getStructureClassAccess().getActorContainerClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8618,10 +8772,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3132:6: ( ruleLogicalSystem )
+                    // InternalRoom.g:3186:6: ( ruleLogicalSystem )
                     {
-                    // InternalRoom.g:3132:6: ( ruleLogicalSystem )
-                    // InternalRoom.g:3133:1: ruleLogicalSystem
+                    // InternalRoom.g:3186:6: ( ruleLogicalSystem )
+                    // InternalRoom.g:3187:1: ruleLogicalSystem
                     {
                      before(grammarAccess.getStructureClassAccess().getLogicalSystemParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8654,13 +8808,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorContainerClass__Alternatives"
-    // InternalRoom.g:3143:1: rule__ActorContainerClass__Alternatives : ( ( ruleActorClass ) | ( ruleSubSystemClass ) );
+    // InternalRoom.g:3197:1: rule__ActorContainerClass__Alternatives : ( ( ruleActorClass ) | ( ruleSubSystemClass ) );
     public final void rule__ActorContainerClass__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3147:1: ( ( ruleActorClass ) | ( ruleSubSystemClass ) )
+            // InternalRoom.g:3201:1: ( ( ruleActorClass ) | ( ruleSubSystemClass ) )
             int alt3=2;
             int LA3_0 = input.LA(1);
 
@@ -8678,10 +8832,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt3) {
                 case 1 :
-                    // InternalRoom.g:3148:1: ( ruleActorClass )
+                    // InternalRoom.g:3202:1: ( ruleActorClass )
                     {
-                    // InternalRoom.g:3148:1: ( ruleActorClass )
-                    // InternalRoom.g:3149:1: ruleActorClass
+                    // InternalRoom.g:3202:1: ( ruleActorClass )
+                    // InternalRoom.g:3203:1: ruleActorClass
                     {
                      before(grammarAccess.getActorContainerClassAccess().getActorClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8697,10 +8851,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3154:6: ( ruleSubSystemClass )
+                    // InternalRoom.g:3208:6: ( ruleSubSystemClass )
                     {
-                    // InternalRoom.g:3154:6: ( ruleSubSystemClass )
-                    // InternalRoom.g:3155:1: ruleSubSystemClass
+                    // InternalRoom.g:3208:6: ( ruleSubSystemClass )
+                    // InternalRoom.g:3209:1: ruleSubSystemClass
                     {
                      before(grammarAccess.getActorContainerClassAccess().getSubSystemClassParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8733,13 +8887,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataType__Alternatives"
-    // InternalRoom.g:3165:1: rule__DataType__Alternatives : ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) );
+    // InternalRoom.g:3219:1: rule__DataType__Alternatives : ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) );
     public final void rule__DataType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3169:1: ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) )
+            // InternalRoom.g:3223:1: ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) )
             int alt4=3;
             switch ( input.LA(1) ) {
             case 47:
@@ -8767,10 +8921,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt4) {
                 case 1 :
-                    // InternalRoom.g:3170:1: ( rulePrimitiveType )
+                    // InternalRoom.g:3224:1: ( rulePrimitiveType )
                     {
-                    // InternalRoom.g:3170:1: ( rulePrimitiveType )
-                    // InternalRoom.g:3171:1: rulePrimitiveType
+                    // InternalRoom.g:3224:1: ( rulePrimitiveType )
+                    // InternalRoom.g:3225:1: rulePrimitiveType
                     {
                      before(grammarAccess.getDataTypeAccess().getPrimitiveTypeParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8786,10 +8940,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3176:6: ( ruleEnumerationType )
+                    // InternalRoom.g:3230:6: ( ruleEnumerationType )
                     {
-                    // InternalRoom.g:3176:6: ( ruleEnumerationType )
-                    // InternalRoom.g:3177:1: ruleEnumerationType
+                    // InternalRoom.g:3230:6: ( ruleEnumerationType )
+                    // InternalRoom.g:3231:1: ruleEnumerationType
                     {
                      before(grammarAccess.getDataTypeAccess().getEnumerationTypeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8805,10 +8959,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3182:6: ( ruleComplexType )
+                    // InternalRoom.g:3236:6: ( ruleComplexType )
                     {
-                    // InternalRoom.g:3182:6: ( ruleComplexType )
-                    // InternalRoom.g:3183:1: ruleComplexType
+                    // InternalRoom.g:3236:6: ( ruleComplexType )
+                    // InternalRoom.g:3237:1: ruleComplexType
                     {
                      before(grammarAccess.getDataTypeAccess().getComplexTypeParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -8841,13 +8995,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ComplexType__Alternatives"
-    // InternalRoom.g:3193:1: rule__ComplexType__Alternatives : ( ( ruleDataClass ) | ( ruleExternalType ) );
+    // InternalRoom.g:3247:1: rule__ComplexType__Alternatives : ( ( ruleDataClass ) | ( ruleExternalType ) );
     public final void rule__ComplexType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3197:1: ( ( ruleDataClass ) | ( ruleExternalType ) )
+            // InternalRoom.g:3251:1: ( ( ruleDataClass ) | ( ruleExternalType ) )
             int alt5=2;
             int LA5_0 = input.LA(1);
 
@@ -8865,10 +9019,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt5) {
                 case 1 :
-                    // InternalRoom.g:3198:1: ( ruleDataClass )
+                    // InternalRoom.g:3252:1: ( ruleDataClass )
                     {
-                    // InternalRoom.g:3198:1: ( ruleDataClass )
-                    // InternalRoom.g:3199:1: ruleDataClass
+                    // InternalRoom.g:3252:1: ( ruleDataClass )
+                    // InternalRoom.g:3253:1: ruleDataClass
                     {
                      before(grammarAccess.getComplexTypeAccess().getDataClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8884,10 +9038,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3204:6: ( ruleExternalType )
+                    // InternalRoom.g:3258:6: ( ruleExternalType )
                     {
-                    // InternalRoom.g:3204:6: ( ruleExternalType )
-                    // InternalRoom.g:3205:1: ruleExternalType
+                    // InternalRoom.g:3258:6: ( ruleExternalType )
+                    // InternalRoom.g:3259:1: ruleExternalType
                     {
                      before(grammarAccess.getComplexTypeAccess().getExternalTypeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8920,13 +9074,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Alternatives_9"
-    // InternalRoom.g:3215:1: rule__DataClass__Alternatives_9 : ( ( ( rule__DataClass__OperationsAssignment_9_0 ) ) | ( ( rule__DataClass__StructorsAssignment_9_1 ) ) | ( ( rule__DataClass__AttributesAssignment_9_2 ) ) );
+    // InternalRoom.g:3269:1: rule__DataClass__Alternatives_9 : ( ( ( rule__DataClass__OperationsAssignment_9_0 ) ) | ( ( rule__DataClass__StructorsAssignment_9_1 ) ) | ( ( rule__DataClass__AttributesAssignment_9_2 ) ) );
     public final void rule__DataClass__Alternatives_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3219:1: ( ( ( rule__DataClass__OperationsAssignment_9_0 ) ) | ( ( rule__DataClass__StructorsAssignment_9_1 ) ) | ( ( rule__DataClass__AttributesAssignment_9_2 ) ) )
+            // InternalRoom.g:3273:1: ( ( ( rule__DataClass__OperationsAssignment_9_0 ) ) | ( ( rule__DataClass__StructorsAssignment_9_1 ) ) | ( ( rule__DataClass__AttributesAssignment_9_2 ) ) )
             int alt6=3;
             switch ( input.LA(1) ) {
             case 64:
@@ -8955,14 +9109,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt6) {
                 case 1 :
-                    // InternalRoom.g:3220:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
+                    // InternalRoom.g:3274:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
                     {
-                    // InternalRoom.g:3220:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
-                    // InternalRoom.g:3221:1: ( rule__DataClass__OperationsAssignment_9_0 )
+                    // InternalRoom.g:3274:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
+                    // InternalRoom.g:3275:1: ( rule__DataClass__OperationsAssignment_9_0 )
                     {
                      before(grammarAccess.getDataClassAccess().getOperationsAssignment_9_0()); 
-                    // InternalRoom.g:3222:1: ( rule__DataClass__OperationsAssignment_9_0 )
-                    // InternalRoom.g:3222:2: rule__DataClass__OperationsAssignment_9_0
+                    // InternalRoom.g:3276:1: ( rule__DataClass__OperationsAssignment_9_0 )
+                    // InternalRoom.g:3276:2: rule__DataClass__OperationsAssignment_9_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__OperationsAssignment_9_0();
@@ -8980,14 +9134,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3226:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
+                    // InternalRoom.g:3280:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
                     {
-                    // InternalRoom.g:3226:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
-                    // InternalRoom.g:3227:1: ( rule__DataClass__StructorsAssignment_9_1 )
+                    // InternalRoom.g:3280:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
+                    // InternalRoom.g:3281:1: ( rule__DataClass__StructorsAssignment_9_1 )
                     {
                      before(grammarAccess.getDataClassAccess().getStructorsAssignment_9_1()); 
-                    // InternalRoom.g:3228:1: ( rule__DataClass__StructorsAssignment_9_1 )
-                    // InternalRoom.g:3228:2: rule__DataClass__StructorsAssignment_9_1
+                    // InternalRoom.g:3282:1: ( rule__DataClass__StructorsAssignment_9_1 )
+                    // InternalRoom.g:3282:2: rule__DataClass__StructorsAssignment_9_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__StructorsAssignment_9_1();
@@ -9005,14 +9159,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3232:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
+                    // InternalRoom.g:3286:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
                     {
-                    // InternalRoom.g:3232:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
-                    // InternalRoom.g:3233:1: ( rule__DataClass__AttributesAssignment_9_2 )
+                    // InternalRoom.g:3286:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
+                    // InternalRoom.g:3287:1: ( rule__DataClass__AttributesAssignment_9_2 )
                     {
                      before(grammarAccess.getDataClassAccess().getAttributesAssignment_9_2()); 
-                    // InternalRoom.g:3234:1: ( rule__DataClass__AttributesAssignment_9_2 )
-                    // InternalRoom.g:3234:2: rule__DataClass__AttributesAssignment_9_2
+                    // InternalRoom.g:3288:1: ( rule__DataClass__AttributesAssignment_9_2 )
+                    // InternalRoom.g:3288:2: rule__DataClass__AttributesAssignment_9_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__AttributesAssignment_9_2();
@@ -9047,13 +9201,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Alternatives_6_1"
-    // InternalRoom.g:3244:1: rule__StandardOperation__Alternatives_6_1 : ( ( 'void' ) | ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) ) );
+    // InternalRoom.g:3298:1: rule__StandardOperation__Alternatives_6_1 : ( ( 'void' ) | ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) ) );
     public final void rule__StandardOperation__Alternatives_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3248:1: ( ( 'void' ) | ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) ) )
+            // InternalRoom.g:3302:1: ( ( 'void' ) | ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) ) )
             int alt7=2;
             int LA7_0 = input.LA(1);
 
@@ -9071,10 +9225,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt7) {
                 case 1 :
-                    // InternalRoom.g:3249:1: ( 'void' )
+                    // InternalRoom.g:3303:1: ( 'void' )
                     {
-                    // InternalRoom.g:3249:1: ( 'void' )
-                    // InternalRoom.g:3250:1: 'void'
+                    // InternalRoom.g:3303:1: ( 'void' )
+                    // InternalRoom.g:3304:1: 'void'
                     {
                      before(grammarAccess.getStandardOperationAccess().getVoidKeyword_6_1_0()); 
                     match(input,13,FOLLOW_2); 
@@ -9086,14 +9240,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3257:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
+                    // InternalRoom.g:3311:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
                     {
-                    // InternalRoom.g:3257:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
-                    // InternalRoom.g:3258:1: ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 )
+                    // InternalRoom.g:3311:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
+                    // InternalRoom.g:3312:1: ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 )
                     {
                      before(grammarAccess.getStandardOperationAccess().getReturnTypeAssignment_6_1_1()); 
-                    // InternalRoom.g:3259:1: ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 )
-                    // InternalRoom.g:3259:2: rule__StandardOperation__ReturnTypeAssignment_6_1_1
+                    // InternalRoom.g:3313:1: ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 )
+                    // InternalRoom.g:3313:2: rule__StandardOperation__ReturnTypeAssignment_6_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__ReturnTypeAssignment_6_1_1();
@@ -9128,13 +9282,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Alternatives_5"
-    // InternalRoom.g:3268:1: rule__PortOperation__Alternatives_5 : ( ( ( rule__PortOperation__Group_5_0__0 ) ) | ( ( rule__PortOperation__Group_5_1__0 ) ) );
+    // InternalRoom.g:3322:1: rule__PortOperation__Alternatives_5 : ( ( ( rule__PortOperation__Group_5_0__0 ) ) | ( ( rule__PortOperation__Group_5_1__0 ) ) );
     public final void rule__PortOperation__Alternatives_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3272:1: ( ( ( rule__PortOperation__Group_5_0__0 ) ) | ( ( rule__PortOperation__Group_5_1__0 ) ) )
+            // InternalRoom.g:3326:1: ( ( ( rule__PortOperation__Group_5_0__0 ) ) | ( ( rule__PortOperation__Group_5_1__0 ) ) )
             int alt8=2;
             int LA8_0 = input.LA(1);
 
@@ -9152,14 +9306,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt8) {
                 case 1 :
-                    // InternalRoom.g:3273:1: ( ( rule__PortOperation__Group_5_0__0 ) )
+                    // InternalRoom.g:3327:1: ( ( rule__PortOperation__Group_5_0__0 ) )
                     {
-                    // InternalRoom.g:3273:1: ( ( rule__PortOperation__Group_5_0__0 ) )
-                    // InternalRoom.g:3274:1: ( rule__PortOperation__Group_5_0__0 )
+                    // InternalRoom.g:3327:1: ( ( rule__PortOperation__Group_5_0__0 ) )
+                    // InternalRoom.g:3328:1: ( rule__PortOperation__Group_5_0__0 )
                     {
                      before(grammarAccess.getPortOperationAccess().getGroup_5_0()); 
-                    // InternalRoom.g:3275:1: ( rule__PortOperation__Group_5_0__0 )
-                    // InternalRoom.g:3275:2: rule__PortOperation__Group_5_0__0
+                    // InternalRoom.g:3329:1: ( rule__PortOperation__Group_5_0__0 )
+                    // InternalRoom.g:3329:2: rule__PortOperation__Group_5_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_5_0__0();
@@ -9177,14 +9331,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3279:6: ( ( rule__PortOperation__Group_5_1__0 ) )
+                    // InternalRoom.g:3333:6: ( ( rule__PortOperation__Group_5_1__0 ) )
                     {
-                    // InternalRoom.g:3279:6: ( ( rule__PortOperation__Group_5_1__0 ) )
-                    // InternalRoom.g:3280:1: ( rule__PortOperation__Group_5_1__0 )
+                    // InternalRoom.g:3333:6: ( ( rule__PortOperation__Group_5_1__0 ) )
+                    // InternalRoom.g:3334:1: ( rule__PortOperation__Group_5_1__0 )
                     {
                      before(grammarAccess.getPortOperationAccess().getGroup_5_1()); 
-                    // InternalRoom.g:3281:1: ( rule__PortOperation__Group_5_1__0 )
-                    // InternalRoom.g:3281:2: rule__PortOperation__Group_5_1__0
+                    // InternalRoom.g:3335:1: ( rule__PortOperation__Group_5_1__0 )
+                    // InternalRoom.g:3335:2: rule__PortOperation__Group_5_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_5_1__0();
@@ -9219,13 +9373,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Alternatives_5_0_1"
-    // InternalRoom.g:3290:1: rule__PortOperation__Alternatives_5_0_1 : ( ( 'void' ) | ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) ) );
+    // InternalRoom.g:3344:1: rule__PortOperation__Alternatives_5_0_1 : ( ( 'void' ) | ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) ) );
     public final void rule__PortOperation__Alternatives_5_0_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3294:1: ( ( 'void' ) | ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) ) )
+            // InternalRoom.g:3348:1: ( ( 'void' ) | ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) ) )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -9243,10 +9397,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalRoom.g:3295:1: ( 'void' )
+                    // InternalRoom.g:3349:1: ( 'void' )
                     {
-                    // InternalRoom.g:3295:1: ( 'void' )
-                    // InternalRoom.g:3296:1: 'void'
+                    // InternalRoom.g:3349:1: ( 'void' )
+                    // InternalRoom.g:3350:1: 'void'
                     {
                      before(grammarAccess.getPortOperationAccess().getVoidKeyword_5_0_1_0()); 
                     match(input,13,FOLLOW_2); 
@@ -9258,14 +9412,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3303:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
+                    // InternalRoom.g:3357:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
                     {
-                    // InternalRoom.g:3303:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
-                    // InternalRoom.g:3304:1: ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 )
+                    // InternalRoom.g:3357:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
+                    // InternalRoom.g:3358:1: ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 )
                     {
                      before(grammarAccess.getPortOperationAccess().getReturnTypeAssignment_5_0_1_1()); 
-                    // InternalRoom.g:3305:1: ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 )
-                    // InternalRoom.g:3305:2: rule__PortOperation__ReturnTypeAssignment_5_0_1_1
+                    // InternalRoom.g:3359:1: ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 )
+                    // InternalRoom.g:3359:2: rule__PortOperation__ReturnTypeAssignment_5_0_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__ReturnTypeAssignment_5_0_1_1();
@@ -9300,13 +9454,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__NameAlternatives_0_0"
-    // InternalRoom.g:3314:1: rule__ClassStructor__NameAlternatives_0_0 : ( ( 'ctor' ) | ( 'dtor' ) );
+    // InternalRoom.g:3368:1: rule__ClassStructor__NameAlternatives_0_0 : ( ( 'ctor' ) | ( 'dtor' ) );
     public final void rule__ClassStructor__NameAlternatives_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3318:1: ( ( 'ctor' ) | ( 'dtor' ) )
+            // InternalRoom.g:3372:1: ( ( 'ctor' ) | ( 'dtor' ) )
             int alt10=2;
             int LA10_0 = input.LA(1);
 
@@ -9324,10 +9478,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt10) {
                 case 1 :
-                    // InternalRoom.g:3319:1: ( 'ctor' )
+                    // InternalRoom.g:3373:1: ( 'ctor' )
                     {
-                    // InternalRoom.g:3319:1: ( 'ctor' )
-                    // InternalRoom.g:3320:1: 'ctor'
+                    // InternalRoom.g:3373:1: ( 'ctor' )
+                    // InternalRoom.g:3374:1: 'ctor'
                     {
                      before(grammarAccess.getClassStructorAccess().getNameCtorKeyword_0_0_0()); 
                     match(input,14,FOLLOW_2); 
@@ -9339,10 +9493,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3327:6: ( 'dtor' )
+                    // InternalRoom.g:3381:6: ( 'dtor' )
                     {
-                    // InternalRoom.g:3327:6: ( 'dtor' )
-                    // InternalRoom.g:3328:1: 'dtor'
+                    // InternalRoom.g:3381:6: ( 'dtor' )
+                    // InternalRoom.g:3382:1: 'dtor'
                     {
                      before(grammarAccess.getClassStructorAccess().getNameDtorKeyword_0_0_1()); 
                     match(input,15,FOLLOW_2); 
@@ -9371,13 +9525,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GeneralProtocolClass__Alternatives"
-    // InternalRoom.g:3340:1: rule__GeneralProtocolClass__Alternatives : ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) );
+    // InternalRoom.g:3394:1: rule__GeneralProtocolClass__Alternatives : ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) );
     public final void rule__GeneralProtocolClass__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3344:1: ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) )
+            // InternalRoom.g:3398:1: ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) )
             int alt11=2;
             int LA11_0 = input.LA(1);
 
@@ -9395,10 +9549,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt11) {
                 case 1 :
-                    // InternalRoom.g:3345:1: ( ruleProtocolClass )
+                    // InternalRoom.g:3399:1: ( ruleProtocolClass )
                     {
-                    // InternalRoom.g:3345:1: ( ruleProtocolClass )
-                    // InternalRoom.g:3346:1: ruleProtocolClass
+                    // InternalRoom.g:3399:1: ( ruleProtocolClass )
+                    // InternalRoom.g:3400:1: ruleProtocolClass
                     {
                      before(grammarAccess.getGeneralProtocolClassAccess().getProtocolClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -9414,10 +9568,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3351:6: ( ruleCompoundProtocolClass )
+                    // InternalRoom.g:3405:6: ( ruleCompoundProtocolClass )
                     {
-                    // InternalRoom.g:3351:6: ( ruleCompoundProtocolClass )
-                    // InternalRoom.g:3352:1: ruleCompoundProtocolClass
+                    // InternalRoom.g:3405:6: ( ruleCompoundProtocolClass )
+                    // InternalRoom.g:3406:1: ruleCompoundProtocolClass
                     {
                      before(grammarAccess.getGeneralProtocolClassAccess().getCompoundProtocolClassParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -9450,13 +9604,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Alternatives_3"
-    // InternalRoom.g:3362:1: rule__PortClass__Alternatives_3 : ( ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) ) | ( ( rule__PortClass__OperationsAssignment_3_1 ) ) | ( ( rule__PortClass__AttributesAssignment_3_2 ) ) );
+    // InternalRoom.g:3416:1: rule__PortClass__Alternatives_3 : ( ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) ) | ( ( rule__PortClass__OperationsAssignment_3_1 ) ) | ( ( rule__PortClass__AttributesAssignment_3_2 ) ) );
     public final void rule__PortClass__Alternatives_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3366:1: ( ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) ) | ( ( rule__PortClass__OperationsAssignment_3_1 ) ) | ( ( rule__PortClass__AttributesAssignment_3_2 ) ) )
+            // InternalRoom.g:3420:1: ( ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) ) | ( ( rule__PortClass__OperationsAssignment_3_1 ) ) | ( ( rule__PortClass__AttributesAssignment_3_2 ) ) )
             int alt12=3;
             switch ( input.LA(1) ) {
             case 73:
@@ -9483,14 +9637,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt12) {
                 case 1 :
-                    // InternalRoom.g:3367:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
+                    // InternalRoom.g:3421:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
                     {
-                    // InternalRoom.g:3367:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
-                    // InternalRoom.g:3368:1: ( rule__PortClass__MsgHandlersAssignment_3_0 )
+                    // InternalRoom.g:3421:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
+                    // InternalRoom.g:3422:1: ( rule__PortClass__MsgHandlersAssignment_3_0 )
                     {
                      before(grammarAccess.getPortClassAccess().getMsgHandlersAssignment_3_0()); 
-                    // InternalRoom.g:3369:1: ( rule__PortClass__MsgHandlersAssignment_3_0 )
-                    // InternalRoom.g:3369:2: rule__PortClass__MsgHandlersAssignment_3_0
+                    // InternalRoom.g:3423:1: ( rule__PortClass__MsgHandlersAssignment_3_0 )
+                    // InternalRoom.g:3423:2: rule__PortClass__MsgHandlersAssignment_3_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__MsgHandlersAssignment_3_0();
@@ -9508,14 +9662,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3373:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
+                    // InternalRoom.g:3427:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
                     {
-                    // InternalRoom.g:3373:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
-                    // InternalRoom.g:3374:1: ( rule__PortClass__OperationsAssignment_3_1 )
+                    // InternalRoom.g:3427:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
+                    // InternalRoom.g:3428:1: ( rule__PortClass__OperationsAssignment_3_1 )
                     {
                      before(grammarAccess.getPortClassAccess().getOperationsAssignment_3_1()); 
-                    // InternalRoom.g:3375:1: ( rule__PortClass__OperationsAssignment_3_1 )
-                    // InternalRoom.g:3375:2: rule__PortClass__OperationsAssignment_3_1
+                    // InternalRoom.g:3429:1: ( rule__PortClass__OperationsAssignment_3_1 )
+                    // InternalRoom.g:3429:2: rule__PortClass__OperationsAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__OperationsAssignment_3_1();
@@ -9533,14 +9687,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3379:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
+                    // InternalRoom.g:3433:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
                     {
-                    // InternalRoom.g:3379:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
-                    // InternalRoom.g:3380:1: ( rule__PortClass__AttributesAssignment_3_2 )
+                    // InternalRoom.g:3433:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
+                    // InternalRoom.g:3434:1: ( rule__PortClass__AttributesAssignment_3_2 )
                     {
                      before(grammarAccess.getPortClassAccess().getAttributesAssignment_3_2()); 
-                    // InternalRoom.g:3381:1: ( rule__PortClass__AttributesAssignment_3_2 )
-                    // InternalRoom.g:3381:2: rule__PortClass__AttributesAssignment_3_2
+                    // InternalRoom.g:3435:1: ( rule__PortClass__AttributesAssignment_3_2 )
+                    // InternalRoom.g:3435:2: rule__PortClass__AttributesAssignment_3_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__AttributesAssignment_3_2();
@@ -9575,25 +9729,25 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageHandler__Alternatives"
-    // InternalRoom.g:3390:1: rule__MessageHandler__Alternatives : ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) );
+    // InternalRoom.g:3444:1: rule__MessageHandler__Alternatives : ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) );
     public final void rule__MessageHandler__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3394:1: ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) )
+            // InternalRoom.g:3448:1: ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) )
             int alt13=2;
             int LA13_0 = input.LA(1);
 
             if ( (LA13_0==73) ) {
                 int LA13_1 = input.LA(2);
 
-                if ( (LA13_1==66) ) {
-                    alt13=1;
-                }
-                else if ( (LA13_1==67) ) {
+                if ( (LA13_1==67) ) {
                     alt13=2;
                 }
+                else if ( (LA13_1==66) ) {
+                    alt13=1;
+                }
                 else {
                     NoViableAltException nvae =
                         new NoViableAltException("", 13, 1, input);
@@ -9609,10 +9763,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalRoom.g:3395:1: ( ruleInMessageHandler )
+                    // InternalRoom.g:3449:1: ( ruleInMessageHandler )
                     {
-                    // InternalRoom.g:3395:1: ( ruleInMessageHandler )
-                    // InternalRoom.g:3396:1: ruleInMessageHandler
+                    // InternalRoom.g:3449:1: ( ruleInMessageHandler )
+                    // InternalRoom.g:3450:1: ruleInMessageHandler
                     {
                      before(grammarAccess.getMessageHandlerAccess().getInMessageHandlerParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -9628,10 +9782,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3401:6: ( ruleOutMessageHandler )
+                    // InternalRoom.g:3455:6: ( ruleOutMessageHandler )
                     {
-                    // InternalRoom.g:3401:6: ( ruleOutMessageHandler )
-                    // InternalRoom.g:3402:1: ruleOutMessageHandler
+                    // InternalRoom.g:3455:6: ( ruleOutMessageHandler )
+                    // InternalRoom.g:3456:1: ruleOutMessageHandler
                     {
                      before(grammarAccess.getMessageHandlerAccess().getOutMessageHandlerParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -9664,13 +9818,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Alternatives_7_2"
-    // InternalRoom.g:3412:1: rule__ActorClass__Alternatives_7_2 : ( ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) ) | ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) ) );
+    // InternalRoom.g:3466:1: rule__ActorClass__Alternatives_7_2 : ( ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) ) | ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) ) );
     public final void rule__ActorClass__Alternatives_7_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3416:1: ( ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) ) | ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) ) )
+            // InternalRoom.g:3470:1: ( ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) ) | ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) ) )
             int alt14=2;
             int LA14_0 = input.LA(1);
 
@@ -9688,14 +9842,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt14) {
                 case 1 :
-                    // InternalRoom.g:3417:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
+                    // InternalRoom.g:3471:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
                     {
-                    // InternalRoom.g:3417:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
-                    // InternalRoom.g:3418:1: ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 )
+                    // InternalRoom.g:3471:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
+                    // InternalRoom.g:3472:1: ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 )
                     {
                      before(grammarAccess.getActorClassAccess().getServiceProvisionPointsAssignment_7_2_0()); 
-                    // InternalRoom.g:3419:1: ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 )
-                    // InternalRoom.g:3419:2: rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0
+                    // InternalRoom.g:3473:1: ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 )
+                    // InternalRoom.g:3473:2: rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0();
@@ -9713,14 +9867,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3423:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
+                    // InternalRoom.g:3477:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
                     {
-                    // InternalRoom.g:3423:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
-                    // InternalRoom.g:3424:1: ( rule__ActorClass__InterfacePortsAssignment_7_2_1 )
+                    // InternalRoom.g:3477:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
+                    // InternalRoom.g:3478:1: ( rule__ActorClass__InterfacePortsAssignment_7_2_1 )
                     {
                      before(grammarAccess.getActorClassAccess().getInterfacePortsAssignment_7_2_1()); 
-                    // InternalRoom.g:3425:1: ( rule__ActorClass__InterfacePortsAssignment_7_2_1 )
-                    // InternalRoom.g:3425:2: rule__ActorClass__InterfacePortsAssignment_7_2_1
+                    // InternalRoom.g:3479:1: ( rule__ActorClass__InterfacePortsAssignment_7_2_1 )
+                    // InternalRoom.g:3479:2: rule__ActorClass__InterfacePortsAssignment_7_2_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__InterfacePortsAssignment_7_2_1();
@@ -9755,13 +9909,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Alternatives_8_6"
-    // InternalRoom.g:3434:1: rule__ActorClass__Alternatives_8_6 : ( ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) ) | ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) ) | ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) ) | ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) ) | ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) ) | ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) ) | ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) ) | ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) ) );
+    // InternalRoom.g:3488:1: rule__ActorClass__Alternatives_8_6 : ( ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) ) | ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) ) | ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) ) | ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) ) | ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) ) | ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) ) | ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) ) | ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) ) );
     public final void rule__ActorClass__Alternatives_8_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3438:1: ( ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) ) | ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) ) | ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) ) | ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) ) | ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) ) | ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) ) | ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) ) | ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) ) )
+            // InternalRoom.g:3492:1: ( ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) ) | ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) ) | ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) ) | ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) ) | ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) ) | ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) ) | ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) ) | ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) ) )
             int alt15=8;
             switch ( input.LA(1) ) {
             case 89:
@@ -9816,14 +9970,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt15) {
                 case 1 :
-                    // InternalRoom.g:3439:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
+                    // InternalRoom.g:3493:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
                     {
-                    // InternalRoom.g:3439:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
-                    // InternalRoom.g:3440:1: ( rule__ActorClass__ConnectionsAssignment_8_6_0 )
+                    // InternalRoom.g:3493:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
+                    // InternalRoom.g:3494:1: ( rule__ActorClass__ConnectionsAssignment_8_6_0 )
                     {
                      before(grammarAccess.getActorClassAccess().getConnectionsAssignment_8_6_0()); 
-                    // InternalRoom.g:3441:1: ( rule__ActorClass__ConnectionsAssignment_8_6_0 )
-                    // InternalRoom.g:3441:2: rule__ActorClass__ConnectionsAssignment_8_6_0
+                    // InternalRoom.g:3495:1: ( rule__ActorClass__ConnectionsAssignment_8_6_0 )
+                    // InternalRoom.g:3495:2: rule__ActorClass__ConnectionsAssignment_8_6_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ConnectionsAssignment_8_6_0();
@@ -9841,14 +9995,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3445:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
+                    // InternalRoom.g:3499:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
                     {
-                    // InternalRoom.g:3445:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
-                    // InternalRoom.g:3446:1: ( rule__ActorClass__BindingsAssignment_8_6_1 )
+                    // InternalRoom.g:3499:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
+                    // InternalRoom.g:3500:1: ( rule__ActorClass__BindingsAssignment_8_6_1 )
                     {
                      before(grammarAccess.getActorClassAccess().getBindingsAssignment_8_6_1()); 
-                    // InternalRoom.g:3447:1: ( rule__ActorClass__BindingsAssignment_8_6_1 )
-                    // InternalRoom.g:3447:2: rule__ActorClass__BindingsAssignment_8_6_1
+                    // InternalRoom.g:3501:1: ( rule__ActorClass__BindingsAssignment_8_6_1 )
+                    // InternalRoom.g:3501:2: rule__ActorClass__BindingsAssignment_8_6_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__BindingsAssignment_8_6_1();
@@ -9866,14 +10020,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3451:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
+                    // InternalRoom.g:3505:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
                     {
-                    // InternalRoom.g:3451:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
-                    // InternalRoom.g:3452:1: ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 )
+                    // InternalRoom.g:3505:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
+                    // InternalRoom.g:3506:1: ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 )
                     {
                      before(grammarAccess.getActorClassAccess().getServiceImplementationsAssignment_8_6_2()); 
-                    // InternalRoom.g:3453:1: ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 )
-                    // InternalRoom.g:3453:2: rule__ActorClass__ServiceImplementationsAssignment_8_6_2
+                    // InternalRoom.g:3507:1: ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 )
+                    // InternalRoom.g:3507:2: rule__ActorClass__ServiceImplementationsAssignment_8_6_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceImplementationsAssignment_8_6_2();
@@ -9891,14 +10045,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3457:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
+                    // InternalRoom.g:3511:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
                     {
-                    // InternalRoom.g:3457:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
-                    // InternalRoom.g:3458:1: ( rule__ActorClass__AttributesAssignment_8_6_3 )
+                    // InternalRoom.g:3511:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
+                    // InternalRoom.g:3512:1: ( rule__ActorClass__AttributesAssignment_8_6_3 )
                     {
                      before(grammarAccess.getActorClassAccess().getAttributesAssignment_8_6_3()); 
-                    // InternalRoom.g:3459:1: ( rule__ActorClass__AttributesAssignment_8_6_3 )
-                    // InternalRoom.g:3459:2: rule__ActorClass__AttributesAssignment_8_6_3
+                    // InternalRoom.g:3513:1: ( rule__ActorClass__AttributesAssignment_8_6_3 )
+                    // InternalRoom.g:3513:2: rule__ActorClass__AttributesAssignment_8_6_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__AttributesAssignment_8_6_3();
@@ -9916,14 +10070,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3463:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
+                    // InternalRoom.g:3517:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
                     {
-                    // InternalRoom.g:3463:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
-                    // InternalRoom.g:3464:1: ( rule__ActorClass__ActorRefsAssignment_8_6_4 )
+                    // InternalRoom.g:3517:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
+                    // InternalRoom.g:3518:1: ( rule__ActorClass__ActorRefsAssignment_8_6_4 )
                     {
                      before(grammarAccess.getActorClassAccess().getActorRefsAssignment_8_6_4()); 
-                    // InternalRoom.g:3465:1: ( rule__ActorClass__ActorRefsAssignment_8_6_4 )
-                    // InternalRoom.g:3465:2: rule__ActorClass__ActorRefsAssignment_8_6_4
+                    // InternalRoom.g:3519:1: ( rule__ActorClass__ActorRefsAssignment_8_6_4 )
+                    // InternalRoom.g:3519:2: rule__ActorClass__ActorRefsAssignment_8_6_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ActorRefsAssignment_8_6_4();
@@ -9941,14 +10095,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3469:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
+                    // InternalRoom.g:3523:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
                     {
-                    // InternalRoom.g:3469:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
-                    // InternalRoom.g:3470:1: ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 )
+                    // InternalRoom.g:3523:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
+                    // InternalRoom.g:3524:1: ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 )
                     {
                      before(grammarAccess.getActorClassAccess().getServiceAccessPointsAssignment_8_6_5()); 
-                    // InternalRoom.g:3471:1: ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 )
-                    // InternalRoom.g:3471:2: rule__ActorClass__ServiceAccessPointsAssignment_8_6_5
+                    // InternalRoom.g:3525:1: ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 )
+                    // InternalRoom.g:3525:2: rule__ActorClass__ServiceAccessPointsAssignment_8_6_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceAccessPointsAssignment_8_6_5();
@@ -9966,14 +10120,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3475:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
+                    // InternalRoom.g:3529:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
                     {
-                    // InternalRoom.g:3475:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
-                    // InternalRoom.g:3476:1: ( rule__ActorClass__InternalPortsAssignment_8_6_6 )
+                    // InternalRoom.g:3529:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
+                    // InternalRoom.g:3530:1: ( rule__ActorClass__InternalPortsAssignment_8_6_6 )
                     {
                      before(grammarAccess.getActorClassAccess().getInternalPortsAssignment_8_6_6()); 
-                    // InternalRoom.g:3477:1: ( rule__ActorClass__InternalPortsAssignment_8_6_6 )
-                    // InternalRoom.g:3477:2: rule__ActorClass__InternalPortsAssignment_8_6_6
+                    // InternalRoom.g:3531:1: ( rule__ActorClass__InternalPortsAssignment_8_6_6 )
+                    // InternalRoom.g:3531:2: rule__ActorClass__InternalPortsAssignment_8_6_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__InternalPortsAssignment_8_6_6();
@@ -9991,14 +10145,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3481:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
+                    // InternalRoom.g:3535:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
                     {
-                    // InternalRoom.g:3481:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
-                    // InternalRoom.g:3482:1: ( rule__ActorClass__ExternalPortsAssignment_8_6_7 )
+                    // InternalRoom.g:3535:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
+                    // InternalRoom.g:3536:1: ( rule__ActorClass__ExternalPortsAssignment_8_6_7 )
                     {
                      before(grammarAccess.getActorClassAccess().getExternalPortsAssignment_8_6_7()); 
-                    // InternalRoom.g:3483:1: ( rule__ActorClass__ExternalPortsAssignment_8_6_7 )
-                    // InternalRoom.g:3483:2: rule__ActorClass__ExternalPortsAssignment_8_6_7
+                    // InternalRoom.g:3537:1: ( rule__ActorClass__ExternalPortsAssignment_8_6_7 )
+                    // InternalRoom.g:3537:2: rule__ActorClass__ExternalPortsAssignment_8_6_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ExternalPortsAssignment_8_6_7();
@@ -10033,13 +10187,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Alternatives_9_4"
-    // InternalRoom.g:3492:1: rule__ActorClass__Alternatives_9_4 : ( ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) ) | ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) ) );
+    // InternalRoom.g:3546:1: rule__ActorClass__Alternatives_9_4 : ( ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) ) | ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) ) );
     public final void rule__ActorClass__Alternatives_9_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3496:1: ( ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) ) | ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) ) )
+            // InternalRoom.g:3550:1: ( ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) ) | ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) ) )
             int alt16=2;
             int LA16_0 = input.LA(1);
 
@@ -10057,14 +10211,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt16) {
                 case 1 :
-                    // InternalRoom.g:3497:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
+                    // InternalRoom.g:3551:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
                     {
-                    // InternalRoom.g:3497:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
-                    // InternalRoom.g:3498:1: ( rule__ActorClass__OperationsAssignment_9_4_0 )
+                    // InternalRoom.g:3551:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
+                    // InternalRoom.g:3552:1: ( rule__ActorClass__OperationsAssignment_9_4_0 )
                     {
                      before(grammarAccess.getActorClassAccess().getOperationsAssignment_9_4_0()); 
-                    // InternalRoom.g:3499:1: ( rule__ActorClass__OperationsAssignment_9_4_0 )
-                    // InternalRoom.g:3499:2: rule__ActorClass__OperationsAssignment_9_4_0
+                    // InternalRoom.g:3553:1: ( rule__ActorClass__OperationsAssignment_9_4_0 )
+                    // InternalRoom.g:3553:2: rule__ActorClass__OperationsAssignment_9_4_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__OperationsAssignment_9_4_0();
@@ -10082,14 +10236,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3503:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
+                    // InternalRoom.g:3557:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
                     {
-                    // InternalRoom.g:3503:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
-                    // InternalRoom.g:3504:1: ( rule__ActorClass__StructorsAssignment_9_4_1 )
+                    // InternalRoom.g:3557:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
+                    // InternalRoom.g:3558:1: ( rule__ActorClass__StructorsAssignment_9_4_1 )
                     {
                      before(grammarAccess.getActorClassAccess().getStructorsAssignment_9_4_1()); 
-                    // InternalRoom.g:3505:1: ( rule__ActorClass__StructorsAssignment_9_4_1 )
-                    // InternalRoom.g:3505:2: rule__ActorClass__StructorsAssignment_9_4_1
+                    // InternalRoom.g:3559:1: ( rule__ActorClass__StructorsAssignment_9_4_1 )
+                    // InternalRoom.g:3559:2: rule__ActorClass__StructorsAssignment_9_4_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StructorsAssignment_9_4_1();
@@ -10124,13 +10278,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InterfaceItem__Alternatives"
-    // InternalRoom.g:3514:1: rule__InterfaceItem__Alternatives : ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) );
+    // InternalRoom.g:3568:1: rule__InterfaceItem__Alternatives : ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) );
     public final void rule__InterfaceItem__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3518:1: ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) )
+            // InternalRoom.g:3572:1: ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) )
             int alt17=3;
             switch ( input.LA(1) ) {
             case 24:
@@ -10158,10 +10312,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt17) {
                 case 1 :
-                    // InternalRoom.g:3519:1: ( rulePort )
+                    // InternalRoom.g:3573:1: ( rulePort )
                     {
-                    // InternalRoom.g:3519:1: ( rulePort )
-                    // InternalRoom.g:3520:1: rulePort
+                    // InternalRoom.g:3573:1: ( rulePort )
+                    // InternalRoom.g:3574:1: rulePort
                     {
                      before(grammarAccess.getInterfaceItemAccess().getPortParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -10177,10 +10331,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3525:6: ( ruleSAP )
+                    // InternalRoom.g:3579:6: ( ruleSAP )
                     {
-                    // InternalRoom.g:3525:6: ( ruleSAP )
-                    // InternalRoom.g:3526:1: ruleSAP
+                    // InternalRoom.g:3579:6: ( ruleSAP )
+                    // InternalRoom.g:3580:1: ruleSAP
                     {
                      before(grammarAccess.getInterfaceItemAccess().getSAPParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -10196,10 +10350,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3531:6: ( ruleSPP )
+                    // InternalRoom.g:3585:6: ( ruleSPP )
                     {
-                    // InternalRoom.g:3531:6: ( ruleSPP )
-                    // InternalRoom.g:3532:1: ruleSPP
+                    // InternalRoom.g:3585:6: ( ruleSPP )
+                    // InternalRoom.g:3586:1: ruleSPP
                     {
                      before(grammarAccess.getInterfaceItemAccess().getSPPParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -10232,13 +10386,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Alternatives_5"
-    // InternalRoom.g:3542:1: rule__LogicalSystem__Alternatives_5 : ( ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) ) | ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) ) | ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) ) );
+    // InternalRoom.g:3596:1: rule__LogicalSystem__Alternatives_5 : ( ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) ) | ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) ) | ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) ) );
     public final void rule__LogicalSystem__Alternatives_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3546:1: ( ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) ) | ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) ) | ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) ) )
+            // InternalRoom.g:3600:1: ( ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) ) | ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) ) | ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) ) )
             int alt18=3;
             switch ( input.LA(1) ) {
             case 89:
@@ -10265,14 +10419,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt18) {
                 case 1 :
-                    // InternalRoom.g:3547:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
+                    // InternalRoom.g:3601:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
                     {
-                    // InternalRoom.g:3547:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
-                    // InternalRoom.g:3548:1: ( rule__LogicalSystem__ConnectionsAssignment_5_0 )
+                    // InternalRoom.g:3601:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
+                    // InternalRoom.g:3602:1: ( rule__LogicalSystem__ConnectionsAssignment_5_0 )
                     {
                      before(grammarAccess.getLogicalSystemAccess().getConnectionsAssignment_5_0()); 
-                    // InternalRoom.g:3549:1: ( rule__LogicalSystem__ConnectionsAssignment_5_0 )
-                    // InternalRoom.g:3549:2: rule__LogicalSystem__ConnectionsAssignment_5_0
+                    // InternalRoom.g:3603:1: ( rule__LogicalSystem__ConnectionsAssignment_5_0 )
+                    // InternalRoom.g:3603:2: rule__LogicalSystem__ConnectionsAssignment_5_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__ConnectionsAssignment_5_0();
@@ -10290,14 +10444,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3553:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
+                    // InternalRoom.g:3607:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
                     {
-                    // InternalRoom.g:3553:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
-                    // InternalRoom.g:3554:1: ( rule__LogicalSystem__BindingsAssignment_5_1 )
+                    // InternalRoom.g:3607:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
+                    // InternalRoom.g:3608:1: ( rule__LogicalSystem__BindingsAssignment_5_1 )
                     {
                      before(grammarAccess.getLogicalSystemAccess().getBindingsAssignment_5_1()); 
-                    // InternalRoom.g:3555:1: ( rule__LogicalSystem__BindingsAssignment_5_1 )
-                    // InternalRoom.g:3555:2: rule__LogicalSystem__BindingsAssignment_5_1
+                    // InternalRoom.g:3609:1: ( rule__LogicalSystem__BindingsAssignment_5_1 )
+                    // InternalRoom.g:3609:2: rule__LogicalSystem__BindingsAssignment_5_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__BindingsAssignment_5_1();
@@ -10315,14 +10469,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3559:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
+                    // InternalRoom.g:3613:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
                     {
-                    // InternalRoom.g:3559:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
-                    // InternalRoom.g:3560:1: ( rule__LogicalSystem__SubSystemsAssignment_5_2 )
+                    // InternalRoom.g:3613:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
+                    // InternalRoom.g:3614:1: ( rule__LogicalSystem__SubSystemsAssignment_5_2 )
                     {
                      before(grammarAccess.getLogicalSystemAccess().getSubSystemsAssignment_5_2()); 
-                    // InternalRoom.g:3561:1: ( rule__LogicalSystem__SubSystemsAssignment_5_2 )
-                    // InternalRoom.g:3561:2: rule__LogicalSystem__SubSystemsAssignment_5_2
+                    // InternalRoom.g:3615:1: ( rule__LogicalSystem__SubSystemsAssignment_5_2 )
+                    // InternalRoom.g:3615:2: rule__LogicalSystem__SubSystemsAssignment_5_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__SubSystemsAssignment_5_2();
@@ -10357,13 +10511,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Alternatives_8"
-    // InternalRoom.g:3571:1: rule__SubSystemClass__Alternatives_8 : ( ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) ) | ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) ) | ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) ) | ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) ) | ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) ) | ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) ) | ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) ) );
+    // InternalRoom.g:3625:1: rule__SubSystemClass__Alternatives_8 : ( ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) ) | ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) ) | ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) ) | ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) ) | ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) ) | ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) ) | ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) ) );
     public final void rule__SubSystemClass__Alternatives_8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3575:1: ( ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) ) | ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) ) | ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) ) | ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) ) | ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) ) | ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) ) | ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) ) )
+            // InternalRoom.g:3629:1: ( ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) ) | ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) ) | ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) ) | ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) ) | ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) ) | ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) ) | ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) ) )
             int alt19=7;
             switch ( input.LA(1) ) {
             case 83:
@@ -10413,14 +10567,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt19) {
                 case 1 :
-                    // InternalRoom.g:3576:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
+                    // InternalRoom.g:3630:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
                     {
-                    // InternalRoom.g:3576:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
-                    // InternalRoom.g:3577:1: ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 )
+                    // InternalRoom.g:3630:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
+                    // InternalRoom.g:3631:1: ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsAssignment_8_0()); 
-                    // InternalRoom.g:3578:1: ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 )
-                    // InternalRoom.g:3578:2: rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0
+                    // InternalRoom.g:3632:1: ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 )
+                    // InternalRoom.g:3632:2: rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0();
@@ -10438,14 +10592,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3582:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
+                    // InternalRoom.g:3636:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
                     {
-                    // InternalRoom.g:3582:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
-                    // InternalRoom.g:3583:1: ( rule__SubSystemClass__ThreadsAssignment_8_1 )
+                    // InternalRoom.g:3636:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
+                    // InternalRoom.g:3637:1: ( rule__SubSystemClass__ThreadsAssignment_8_1 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getThreadsAssignment_8_1()); 
-                    // InternalRoom.g:3584:1: ( rule__SubSystemClass__ThreadsAssignment_8_1 )
-                    // InternalRoom.g:3584:2: rule__SubSystemClass__ThreadsAssignment_8_1
+                    // InternalRoom.g:3638:1: ( rule__SubSystemClass__ThreadsAssignment_8_1 )
+                    // InternalRoom.g:3638:2: rule__SubSystemClass__ThreadsAssignment_8_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ThreadsAssignment_8_1();
@@ -10463,14 +10617,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3588:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
+                    // InternalRoom.g:3642:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
                     {
-                    // InternalRoom.g:3588:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
-                    // InternalRoom.g:3589:1: ( rule__SubSystemClass__ConnectionsAssignment_8_2 )
+                    // InternalRoom.g:3642:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
+                    // InternalRoom.g:3643:1: ( rule__SubSystemClass__ConnectionsAssignment_8_2 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getConnectionsAssignment_8_2()); 
-                    // InternalRoom.g:3590:1: ( rule__SubSystemClass__ConnectionsAssignment_8_2 )
-                    // InternalRoom.g:3590:2: rule__SubSystemClass__ConnectionsAssignment_8_2
+                    // InternalRoom.g:3644:1: ( rule__SubSystemClass__ConnectionsAssignment_8_2 )
+                    // InternalRoom.g:3644:2: rule__SubSystemClass__ConnectionsAssignment_8_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ConnectionsAssignment_8_2();
@@ -10488,14 +10642,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3594:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
+                    // InternalRoom.g:3648:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
                     {
-                    // InternalRoom.g:3594:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
-                    // InternalRoom.g:3595:1: ( rule__SubSystemClass__BindingsAssignment_8_3 )
+                    // InternalRoom.g:3648:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
+                    // InternalRoom.g:3649:1: ( rule__SubSystemClass__BindingsAssignment_8_3 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getBindingsAssignment_8_3()); 
-                    // InternalRoom.g:3596:1: ( rule__SubSystemClass__BindingsAssignment_8_3 )
-                    // InternalRoom.g:3596:2: rule__SubSystemClass__BindingsAssignment_8_3
+                    // InternalRoom.g:3650:1: ( rule__SubSystemClass__BindingsAssignment_8_3 )
+                    // InternalRoom.g:3650:2: rule__SubSystemClass__BindingsAssignment_8_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__BindingsAssignment_8_3();
@@ -10513,14 +10667,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3600:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
+                    // InternalRoom.g:3654:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
                     {
-                    // InternalRoom.g:3600:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
-                    // InternalRoom.g:3601:1: ( rule__SubSystemClass__ActorRefsAssignment_8_4 )
+                    // InternalRoom.g:3654:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
+                    // InternalRoom.g:3655:1: ( rule__SubSystemClass__ActorRefsAssignment_8_4 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getActorRefsAssignment_8_4()); 
-                    // InternalRoom.g:3602:1: ( rule__SubSystemClass__ActorRefsAssignment_8_4 )
-                    // InternalRoom.g:3602:2: rule__SubSystemClass__ActorRefsAssignment_8_4
+                    // InternalRoom.g:3656:1: ( rule__SubSystemClass__ActorRefsAssignment_8_4 )
+                    // InternalRoom.g:3656:2: rule__SubSystemClass__ActorRefsAssignment_8_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ActorRefsAssignment_8_4();
@@ -10538,14 +10692,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3606:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
+                    // InternalRoom.g:3660:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
                     {
-                    // InternalRoom.g:3606:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
-                    // InternalRoom.g:3607:1: ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 )
+                    // InternalRoom.g:3660:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
+                    // InternalRoom.g:3661:1: ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsAssignment_8_5()); 
-                    // InternalRoom.g:3608:1: ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 )
-                    // InternalRoom.g:3608:2: rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5
+                    // InternalRoom.g:3662:1: ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 )
+                    // InternalRoom.g:3662:2: rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5();
@@ -10563,14 +10717,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3612:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
+                    // InternalRoom.g:3666:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
                     {
-                    // InternalRoom.g:3612:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
-                    // InternalRoom.g:3613:1: ( rule__SubSystemClass__RelayPortsAssignment_8_6 )
+                    // InternalRoom.g:3666:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
+                    // InternalRoom.g:3667:1: ( rule__SubSystemClass__RelayPortsAssignment_8_6 )
                     {
                      before(grammarAccess.getSubSystemClassAccess().getRelayPortsAssignment_8_6()); 
-                    // InternalRoom.g:3614:1: ( rule__SubSystemClass__RelayPortsAssignment_8_6 )
-                    // InternalRoom.g:3614:2: rule__SubSystemClass__RelayPortsAssignment_8_6
+                    // InternalRoom.g:3668:1: ( rule__SubSystemClass__RelayPortsAssignment_8_6 )
+                    // InternalRoom.g:3668:2: rule__SubSystemClass__RelayPortsAssignment_8_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__RelayPortsAssignment_8_6();
@@ -10605,13 +10759,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAPoint__Alternatives"
-    // InternalRoom.g:3623:1: rule__SAPoint__Alternatives : ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) );
+    // InternalRoom.g:3677:1: rule__SAPoint__Alternatives : ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) );
     public final void rule__SAPoint__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3627:1: ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) )
+            // InternalRoom.g:3681:1: ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) )
             int alt20=2;
             int LA20_0 = input.LA(1);
 
@@ -10629,10 +10783,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt20) {
                 case 1 :
-                    // InternalRoom.g:3628:1: ( ruleRefSAPoint )
+                    // InternalRoom.g:3682:1: ( ruleRefSAPoint )
                     {
-                    // InternalRoom.g:3628:1: ( ruleRefSAPoint )
-                    // InternalRoom.g:3629:1: ruleRefSAPoint
+                    // InternalRoom.g:3682:1: ( ruleRefSAPoint )
+                    // InternalRoom.g:3683:1: ruleRefSAPoint
                     {
                      before(grammarAccess.getSAPointAccess().getRefSAPointParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -10648,10 +10802,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3634:6: ( ruleRelaySAPoint )
+                    // InternalRoom.g:3688:6: ( ruleRelaySAPoint )
                     {
-                    // InternalRoom.g:3634:6: ( ruleRelaySAPoint )
-                    // InternalRoom.g:3635:1: ruleRelaySAPoint
+                    // InternalRoom.g:3688:6: ( ruleRelaySAPoint )
+                    // InternalRoom.g:3689:1: ruleRelaySAPoint
                     {
                      before(grammarAccess.getSAPointAccess().getRelaySAPointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -10684,13 +10838,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Alternatives_1"
-    // InternalRoom.g:3645:1: rule__MULTIPLICITY__Alternatives_1 : ( ( '*' ) | ( RULE_INT ) );
+    // InternalRoom.g:3699:1: rule__MULTIPLICITY__Alternatives_1 : ( ( '*' ) | ( RULE_INT ) );
     public final void rule__MULTIPLICITY__Alternatives_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3649:1: ( ( '*' ) | ( RULE_INT ) )
+            // InternalRoom.g:3703:1: ( ( '*' ) | ( RULE_INT ) )
             int alt21=2;
             int LA21_0 = input.LA(1);
 
@@ -10708,10 +10862,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt21) {
                 case 1 :
-                    // InternalRoom.g:3650:1: ( '*' )
+                    // InternalRoom.g:3704:1: ( '*' )
                     {
-                    // InternalRoom.g:3650:1: ( '*' )
-                    // InternalRoom.g:3651:1: '*'
+                    // InternalRoom.g:3704:1: ( '*' )
+                    // InternalRoom.g:3705:1: '*'
                     {
                      before(grammarAccess.getMULTIPLICITYAccess().getAsteriskKeyword_1_0()); 
                     match(input,16,FOLLOW_2); 
@@ -10723,10 +10877,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3658:6: ( RULE_INT )
+                    // InternalRoom.g:3712:6: ( RULE_INT )
                     {
-                    // InternalRoom.g:3658:6: ( RULE_INT )
-                    // InternalRoom.g:3659:1: RULE_INT
+                    // InternalRoom.g:3712:6: ( RULE_INT )
+                    // InternalRoom.g:3713:1: RULE_INT
                     {
                      before(grammarAccess.getMULTIPLICITYAccess().getINTTerminalRuleCall_1_1()); 
                     match(input,RULE_INT,FOLLOW_2); 
@@ -10755,13 +10909,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationTargetType__Alternatives"
-    // InternalRoom.g:3669:1: rule__AnnotationTargetType__Alternatives : ( ( 'DataClass' ) | ( 'ActorClass' ) | ( 'ActorBehavior' ) | ( 'ProtocolClass' ) | ( 'CompoundProtocolClass' ) | ( 'SubSystemClass' ) | ( 'LogicalSystem' ) | ( 'Port' ) | ( 'Message' ) );
+    // InternalRoom.g:3723:1: rule__AnnotationTargetType__Alternatives : ( ( 'DataClass' ) | ( 'ActorClass' ) | ( 'ActorBehavior' ) | ( 'ProtocolClass' ) | ( 'CompoundProtocolClass' ) | ( 'SubSystemClass' ) | ( 'LogicalSystem' ) | ( 'Port' ) | ( 'Message' ) );
     public final void rule__AnnotationTargetType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3673:1: ( ( 'DataClass' ) | ( 'ActorClass' ) | ( 'ActorBehavior' ) | ( 'ProtocolClass' ) | ( 'CompoundProtocolClass' ) | ( 'SubSystemClass' ) | ( 'LogicalSystem' ) | ( 'Port' ) | ( 'Message' ) )
+            // InternalRoom.g:3727:1: ( ( 'DataClass' ) | ( 'ActorClass' ) | ( 'ActorBehavior' ) | ( 'ProtocolClass' ) | ( 'CompoundProtocolClass' ) | ( 'SubSystemClass' ) | ( 'LogicalSystem' ) | ( 'Port' ) | ( 'Message' ) )
             int alt22=9;
             switch ( input.LA(1) ) {
             case 17:
@@ -10818,10 +10972,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt22) {
                 case 1 :
-                    // InternalRoom.g:3674:1: ( 'DataClass' )
+                    // InternalRoom.g:3728:1: ( 'DataClass' )
                     {
-                    // InternalRoom.g:3674:1: ( 'DataClass' )
-                    // InternalRoom.g:3675:1: 'DataClass'
+                    // InternalRoom.g:3728:1: ( 'DataClass' )
+                    // InternalRoom.g:3729:1: 'DataClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getDataClassKeyword_0()); 
                     match(input,17,FOLLOW_2); 
@@ -10833,10 +10987,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3682:6: ( 'ActorClass' )
+                    // InternalRoom.g:3736:6: ( 'ActorClass' )
                     {
-                    // InternalRoom.g:3682:6: ( 'ActorClass' )
-                    // InternalRoom.g:3683:1: 'ActorClass'
+                    // InternalRoom.g:3736:6: ( 'ActorClass' )
+                    // InternalRoom.g:3737:1: 'ActorClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getActorClassKeyword_1()); 
                     match(input,18,FOLLOW_2); 
@@ -10848,10 +11002,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3690:6: ( 'ActorBehavior' )
+                    // InternalRoom.g:3744:6: ( 'ActorBehavior' )
                     {
-                    // InternalRoom.g:3690:6: ( 'ActorBehavior' )
-                    // InternalRoom.g:3691:1: 'ActorBehavior'
+                    // InternalRoom.g:3744:6: ( 'ActorBehavior' )
+                    // InternalRoom.g:3745:1: 'ActorBehavior'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getActorBehaviorKeyword_2()); 
                     match(input,19,FOLLOW_2); 
@@ -10863,10 +11017,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3698:6: ( 'ProtocolClass' )
+                    // InternalRoom.g:3752:6: ( 'ProtocolClass' )
                     {
-                    // InternalRoom.g:3698:6: ( 'ProtocolClass' )
-                    // InternalRoom.g:3699:1: 'ProtocolClass'
+                    // InternalRoom.g:3752:6: ( 'ProtocolClass' )
+                    // InternalRoom.g:3753:1: 'ProtocolClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getProtocolClassKeyword_3()); 
                     match(input,20,FOLLOW_2); 
@@ -10878,10 +11032,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3706:6: ( 'CompoundProtocolClass' )
+                    // InternalRoom.g:3760:6: ( 'CompoundProtocolClass' )
                     {
-                    // InternalRoom.g:3706:6: ( 'CompoundProtocolClass' )
-                    // InternalRoom.g:3707:1: 'CompoundProtocolClass'
+                    // InternalRoom.g:3760:6: ( 'CompoundProtocolClass' )
+                    // InternalRoom.g:3761:1: 'CompoundProtocolClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getCompoundProtocolClassKeyword_4()); 
                     match(input,21,FOLLOW_2); 
@@ -10893,10 +11047,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3714:6: ( 'SubSystemClass' )
+                    // InternalRoom.g:3768:6: ( 'SubSystemClass' )
                     {
-                    // InternalRoom.g:3714:6: ( 'SubSystemClass' )
-                    // InternalRoom.g:3715:1: 'SubSystemClass'
+                    // InternalRoom.g:3768:6: ( 'SubSystemClass' )
+                    // InternalRoom.g:3769:1: 'SubSystemClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getSubSystemClassKeyword_5()); 
                     match(input,22,FOLLOW_2); 
@@ -10908,10 +11062,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3722:6: ( 'LogicalSystem' )
+                    // InternalRoom.g:3776:6: ( 'LogicalSystem' )
                     {
-                    // InternalRoom.g:3722:6: ( 'LogicalSystem' )
-                    // InternalRoom.g:3723:1: 'LogicalSystem'
+                    // InternalRoom.g:3776:6: ( 'LogicalSystem' )
+                    // InternalRoom.g:3777:1: 'LogicalSystem'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getLogicalSystemKeyword_6()); 
                     match(input,23,FOLLOW_2); 
@@ -10923,10 +11077,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3730:6: ( 'Port' )
+                    // InternalRoom.g:3784:6: ( 'Port' )
                     {
-                    // InternalRoom.g:3730:6: ( 'Port' )
-                    // InternalRoom.g:3731:1: 'Port'
+                    // InternalRoom.g:3784:6: ( 'Port' )
+                    // InternalRoom.g:3785:1: 'Port'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getPortKeyword_7()); 
                     match(input,24,FOLLOW_2); 
@@ -10938,10 +11092,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 9 :
-                    // InternalRoom.g:3738:6: ( 'Message' )
+                    // InternalRoom.g:3792:6: ( 'Message' )
                     {
-                    // InternalRoom.g:3738:6: ( 'Message' )
-                    // InternalRoom.g:3739:1: 'Message'
+                    // InternalRoom.g:3792:6: ( 'Message' )
+                    // InternalRoom.g:3793:1: 'Message'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getMessageKeyword_8()); 
                     match(input,25,FOLLOW_2); 
@@ -10970,13 +11124,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraphNode__Alternatives"
-    // InternalRoom.g:3751:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) );
+    // InternalRoom.g:3805:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) );
     public final void rule__StateGraphNode__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3755:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) )
+            // InternalRoom.g:3809:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) )
             int alt23=3;
             switch ( input.LA(1) ) {
             case 95:
@@ -11007,10 +11161,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt23) {
                 case 1 :
-                    // InternalRoom.g:3756:1: ( ruleState )
+                    // InternalRoom.g:3810:1: ( ruleState )
                     {
-                    // InternalRoom.g:3756:1: ( ruleState )
-                    // InternalRoom.g:3757:1: ruleState
+                    // InternalRoom.g:3810:1: ( ruleState )
+                    // InternalRoom.g:3811:1: ruleState
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11026,10 +11180,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3762:6: ( ruleChoicePoint )
+                    // InternalRoom.g:3816:6: ( ruleChoicePoint )
                     {
-                    // InternalRoom.g:3762:6: ( ruleChoicePoint )
-                    // InternalRoom.g:3763:1: ruleChoicePoint
+                    // InternalRoom.g:3816:6: ( ruleChoicePoint )
+                    // InternalRoom.g:3817:1: ruleChoicePoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11045,10 +11199,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3768:6: ( ruleTrPoint )
+                    // InternalRoom.g:3822:6: ( ruleTrPoint )
                     {
-                    // InternalRoom.g:3768:6: ( ruleTrPoint )
-                    // InternalRoom.g:3769:1: ruleTrPoint
+                    // InternalRoom.g:3822:6: ( ruleTrPoint )
+                    // InternalRoom.g:3823:1: ruleTrPoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11081,13 +11235,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Alternatives_2"
-    // InternalRoom.g:3780:1: rule__StateGraph__Alternatives_2 : ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) );
+    // InternalRoom.g:3834:1: rule__StateGraph__Alternatives_2 : ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) );
     public final void rule__StateGraph__Alternatives_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3784:1: ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) )
+            // InternalRoom.g:3838:1: ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) )
             int alt24=5;
             switch ( input.LA(1) ) {
             case 95:
@@ -11128,14 +11282,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt24) {
                 case 1 :
-                    // InternalRoom.g:3785:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalRoom.g:3839:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
                     {
-                    // InternalRoom.g:3785:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
-                    // InternalRoom.g:3786:1: ( rule__StateGraph__StatesAssignment_2_0 )
+                    // InternalRoom.g:3839:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalRoom.g:3840:1: ( rule__StateGraph__StatesAssignment_2_0 )
                     {
                      before(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); 
-                    // InternalRoom.g:3787:1: ( rule__StateGraph__StatesAssignment_2_0 )
-                    // InternalRoom.g:3787:2: rule__StateGraph__StatesAssignment_2_0
+                    // InternalRoom.g:3841:1: ( rule__StateGraph__StatesAssignment_2_0 )
+                    // InternalRoom.g:3841:2: rule__StateGraph__StatesAssignment_2_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__StatesAssignment_2_0();
@@ -11153,14 +11307,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3791:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalRoom.g:3845:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
                     {
-                    // InternalRoom.g:3791:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
-                    // InternalRoom.g:3792:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
+                    // InternalRoom.g:3845:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalRoom.g:3846:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
                     {
                      before(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); 
-                    // InternalRoom.g:3793:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
-                    // InternalRoom.g:3793:2: rule__StateGraph__TrPointsAssignment_2_1
+                    // InternalRoom.g:3847:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
+                    // InternalRoom.g:3847:2: rule__StateGraph__TrPointsAssignment_2_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TrPointsAssignment_2_1();
@@ -11178,14 +11332,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3797:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalRoom.g:3851:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
                     {
-                    // InternalRoom.g:3797:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
-                    // InternalRoom.g:3798:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
+                    // InternalRoom.g:3851:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalRoom.g:3852:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
                     {
                      before(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); 
-                    // InternalRoom.g:3799:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
-                    // InternalRoom.g:3799:2: rule__StateGraph__ChPointsAssignment_2_2
+                    // InternalRoom.g:3853:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
+                    // InternalRoom.g:3853:2: rule__StateGraph__ChPointsAssignment_2_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__ChPointsAssignment_2_2();
@@ -11203,14 +11357,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3803:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalRoom.g:3857:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
                     {
-                    // InternalRoom.g:3803:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
-                    // InternalRoom.g:3804:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
+                    // InternalRoom.g:3857:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalRoom.g:3858:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
                     {
                      before(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); 
-                    // InternalRoom.g:3805:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
-                    // InternalRoom.g:3805:2: rule__StateGraph__TransitionsAssignment_2_3
+                    // InternalRoom.g:3859:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
+                    // InternalRoom.g:3859:2: rule__StateGraph__TransitionsAssignment_2_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TransitionsAssignment_2_3();
@@ -11228,14 +11382,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3809:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalRoom.g:3863:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
                     {
-                    // InternalRoom.g:3809:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
-                    // InternalRoom.g:3810:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
+                    // InternalRoom.g:3863:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalRoom.g:3864:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
                     {
                      before(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); 
-                    // InternalRoom.g:3811:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
-                    // InternalRoom.g:3811:2: rule__StateGraph__RefinedTransitionsAssignment_2_4
+                    // InternalRoom.g:3865:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
+                    // InternalRoom.g:3865:2: rule__StateGraph__RefinedTransitionsAssignment_2_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__RefinedTransitionsAssignment_2_4();
@@ -11270,13 +11424,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Alternatives_3"
-    // InternalRoom.g:3820:1: rule__StateMachine__Alternatives_3 : ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) );
+    // InternalRoom.g:3874:1: rule__StateMachine__Alternatives_3 : ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) );
     public final void rule__StateMachine__Alternatives_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3824:1: ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) )
+            // InternalRoom.g:3878:1: ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) )
             int alt25=5;
             switch ( input.LA(1) ) {
             case 95:
@@ -11317,14 +11471,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt25) {
                 case 1 :
-                    // InternalRoom.g:3825:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalRoom.g:3879:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
                     {
-                    // InternalRoom.g:3825:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
-                    // InternalRoom.g:3826:1: ( rule__StateMachine__StatesAssignment_3_0 )
+                    // InternalRoom.g:3879:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalRoom.g:3880:1: ( rule__StateMachine__StatesAssignment_3_0 )
                     {
                      before(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); 
-                    // InternalRoom.g:3827:1: ( rule__StateMachine__StatesAssignment_3_0 )
-                    // InternalRoom.g:3827:2: rule__StateMachine__StatesAssignment_3_0
+                    // InternalRoom.g:3881:1: ( rule__StateMachine__StatesAssignment_3_0 )
+                    // InternalRoom.g:3881:2: rule__StateMachine__StatesAssignment_3_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__StatesAssignment_3_0();
@@ -11342,14 +11496,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3831:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalRoom.g:3885:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
                     {
-                    // InternalRoom.g:3831:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
-                    // InternalRoom.g:3832:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
+                    // InternalRoom.g:3885:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalRoom.g:3886:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
                     {
                      before(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); 
-                    // InternalRoom.g:3833:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
-                    // InternalRoom.g:3833:2: rule__StateMachine__TrPointsAssignment_3_1
+                    // InternalRoom.g:3887:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
+                    // InternalRoom.g:3887:2: rule__StateMachine__TrPointsAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TrPointsAssignment_3_1();
@@ -11367,14 +11521,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3837:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalRoom.g:3891:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
                     {
-                    // InternalRoom.g:3837:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
-                    // InternalRoom.g:3838:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
+                    // InternalRoom.g:3891:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalRoom.g:3892:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
                     {
                      before(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); 
-                    // InternalRoom.g:3839:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
-                    // InternalRoom.g:3839:2: rule__StateMachine__ChPointsAssignment_3_2
+                    // InternalRoom.g:3893:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
+                    // InternalRoom.g:3893:2: rule__StateMachine__ChPointsAssignment_3_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__ChPointsAssignment_3_2();
@@ -11392,14 +11546,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3843:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalRoom.g:3897:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
                     {
-                    // InternalRoom.g:3843:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
-                    // InternalRoom.g:3844:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
+                    // InternalRoom.g:3897:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalRoom.g:3898:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
                     {
                      before(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); 
-                    // InternalRoom.g:3845:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
-                    // InternalRoom.g:3845:2: rule__StateMachine__TransitionsAssignment_3_3
+                    // InternalRoom.g:3899:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
+                    // InternalRoom.g:3899:2: rule__StateMachine__TransitionsAssignment_3_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TransitionsAssignment_3_3();
@@ -11417,14 +11571,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3849:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalRoom.g:3903:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
                     {
-                    // InternalRoom.g:3849:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
-                    // InternalRoom.g:3850:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
+                    // InternalRoom.g:3903:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalRoom.g:3904:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
                     {
                      before(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); 
-                    // InternalRoom.g:3851:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
-                    // InternalRoom.g:3851:2: rule__StateMachine__RefinedTransitionsAssignment_3_4
+                    // InternalRoom.g:3905:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
+                    // InternalRoom.g:3905:2: rule__StateMachine__RefinedTransitionsAssignment_3_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__RefinedTransitionsAssignment_3_4();
@@ -11459,13 +11613,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__State__Alternatives"
-    // InternalRoom.g:3860:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) );
+    // InternalRoom.g:3914:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) );
     public final void rule__State__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3864:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) )
+            // InternalRoom.g:3918:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) )
             int alt26=2;
             int LA26_0 = input.LA(1);
 
@@ -11483,10 +11637,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt26) {
                 case 1 :
-                    // InternalRoom.g:3865:1: ( ruleSimpleState )
+                    // InternalRoom.g:3919:1: ( ruleSimpleState )
                     {
-                    // InternalRoom.g:3865:1: ( ruleSimpleState )
-                    // InternalRoom.g:3866:1: ruleSimpleState
+                    // InternalRoom.g:3919:1: ( ruleSimpleState )
+                    // InternalRoom.g:3920:1: ruleSimpleState
                     {
                      before(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11502,10 +11656,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3871:6: ( ruleRefinedState )
+                    // InternalRoom.g:3925:6: ( ruleRefinedState )
                     {
-                    // InternalRoom.g:3871:6: ( ruleRefinedState )
-                    // InternalRoom.g:3872:1: ruleRefinedState
+                    // InternalRoom.g:3925:6: ( ruleRefinedState )
+                    // InternalRoom.g:3926:1: ruleRefinedState
                     {
                      before(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11538,13 +11692,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Alternatives"
-    // InternalRoom.g:3882:1: rule__DetailCode__Alternatives : ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) );
+    // InternalRoom.g:3936:1: rule__DetailCode__Alternatives : ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) );
     public final void rule__DetailCode__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3886:1: ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) )
+            // InternalRoom.g:3940:1: ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) )
             int alt27=2;
             int LA27_0 = input.LA(1);
 
@@ -11562,14 +11716,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt27) {
                 case 1 :
-                    // InternalRoom.g:3887:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalRoom.g:3941:1: ( ( rule__DetailCode__Group_0__0 ) )
                     {
-                    // InternalRoom.g:3887:1: ( ( rule__DetailCode__Group_0__0 ) )
-                    // InternalRoom.g:3888:1: ( rule__DetailCode__Group_0__0 )
+                    // InternalRoom.g:3941:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalRoom.g:3942:1: ( rule__DetailCode__Group_0__0 )
                     {
                      before(grammarAccess.getDetailCodeAccess().getGroup_0()); 
-                    // InternalRoom.g:3889:1: ( rule__DetailCode__Group_0__0 )
-                    // InternalRoom.g:3889:2: rule__DetailCode__Group_0__0
+                    // InternalRoom.g:3943:1: ( rule__DetailCode__Group_0__0 )
+                    // InternalRoom.g:3943:2: rule__DetailCode__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_0__0();
@@ -11587,14 +11741,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3893:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalRoom.g:3947:6: ( ( rule__DetailCode__Group_1__0 ) )
                     {
-                    // InternalRoom.g:3893:6: ( ( rule__DetailCode__Group_1__0 ) )
-                    // InternalRoom.g:3894:1: ( rule__DetailCode__Group_1__0 )
+                    // InternalRoom.g:3947:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalRoom.g:3948:1: ( rule__DetailCode__Group_1__0 )
                     {
                      before(grammarAccess.getDetailCodeAccess().getGroup_1()); 
-                    // InternalRoom.g:3895:1: ( rule__DetailCode__Group_1__0 )
-                    // InternalRoom.g:3895:2: rule__DetailCode__Group_1__0
+                    // InternalRoom.g:3949:1: ( rule__DetailCode__Group_1__0 )
+                    // InternalRoom.g:3949:2: rule__DetailCode__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_1__0();
@@ -11629,13 +11783,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPoint__Alternatives"
-    // InternalRoom.g:3904:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) );
+    // InternalRoom.g:3958:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) );
     public final void rule__TrPoint__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3908:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) )
+            // InternalRoom.g:3962:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) )
             int alt28=3;
             switch ( input.LA(1) ) {
             case 101:
@@ -11663,10 +11817,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt28) {
                 case 1 :
-                    // InternalRoom.g:3909:1: ( ruleTransitionPoint )
+                    // InternalRoom.g:3963:1: ( ruleTransitionPoint )
                     {
-                    // InternalRoom.g:3909:1: ( ruleTransitionPoint )
-                    // InternalRoom.g:3910:1: ruleTransitionPoint
+                    // InternalRoom.g:3963:1: ( ruleTransitionPoint )
+                    // InternalRoom.g:3964:1: ruleTransitionPoint
                     {
                      before(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11682,10 +11836,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3915:6: ( ruleEntryPoint )
+                    // InternalRoom.g:3969:6: ( ruleEntryPoint )
                     {
-                    // InternalRoom.g:3915:6: ( ruleEntryPoint )
-                    // InternalRoom.g:3916:1: ruleEntryPoint
+                    // InternalRoom.g:3969:6: ( ruleEntryPoint )
+                    // InternalRoom.g:3970:1: ruleEntryPoint
                     {
                      before(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11701,10 +11855,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3921:6: ( ruleExitPoint )
+                    // InternalRoom.g:3975:6: ( ruleExitPoint )
                     {
-                    // InternalRoom.g:3921:6: ( ruleExitPoint )
-                    // InternalRoom.g:3922:1: ruleExitPoint
+                    // InternalRoom.g:3975:6: ( ruleExitPoint )
+                    // InternalRoom.g:3976:1: ruleExitPoint
                     {
                      before(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11736,81 +11890,160 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__TrPoint__Alternatives"
 
 
-    // $ANTLR start "rule__Transition__Alternatives"
-    // InternalRoom.g:3933:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) );
-    public final void rule__Transition__Alternatives() throws RecognitionException {
+    // $ANTLR start "rule__TransitionBase__Alternatives"
+    // InternalRoom.g:3986:1: rule__TransitionBase__Alternatives : ( ( ruleTransition ) | ( ruleRefinedTransition ) );
+    public final void rule__TransitionBase__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3937:1: ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) )
+            // InternalRoom.g:3990:1: ( ( ruleTransition ) | ( ruleRefinedTransition ) )
             int alt29=2;
             int LA29_0 = input.LA(1);
 
             if ( (LA29_0==105) ) {
-                int LA29_1 = input.LA(2);
+                alt29=1;
+            }
+            else if ( (LA29_0==112) ) {
+                alt29=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 29, 0, input);
+
+                throw nvae;
+            }
+            switch (alt29) {
+                case 1 :
+                    // InternalRoom.g:3991:1: ( ruleTransition )
+                    {
+                    // InternalRoom.g:3991:1: ( ruleTransition )
+                    // InternalRoom.g:3992:1: ruleTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+                    pushFollow(FOLLOW_2);
+                    ruleTransition();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+
+                    }
 
-                if ( (LA29_1==RULE_ID) ) {
-                    int LA29_2 = input.LA(3);
 
-                    if ( (LA29_2==46) ) {
-                        int LA29_3 = input.LA(4);
+                    }
+                    break;
+                case 2 :
+                    // InternalRoom.g:3997:6: ( ruleRefinedTransition )
+                    {
+                    // InternalRoom.g:3997:6: ( ruleRefinedTransition )
+                    // InternalRoom.g:3998:1: ruleRefinedTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+                    pushFollow(FOLLOW_2);
+                    ruleRefinedTransition();
 
-                        if ( (LA29_3==106) ) {
-                            alt29=1;
+                    state._fsp--;
+
+                     after(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransitionBase__Alternatives"
+
+
+    // $ANTLR start "rule__Transition__Alternatives"
+    // InternalRoom.g:4008:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) );
+    public final void rule__Transition__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:4012:1: ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) )
+            int alt30=2;
+            int LA30_0 = input.LA(1);
+
+            if ( (LA30_0==105) ) {
+                int LA30_1 = input.LA(2);
+
+                if ( (LA30_1==RULE_ID) ) {
+                    int LA30_2 = input.LA(3);
+
+                    if ( (LA30_2==46) ) {
+                        int LA30_3 = input.LA(4);
+
+                        if ( (LA30_3==RULE_ID||(LA30_3>=113 && LA30_3<=114)) ) {
+                            alt30=2;
                         }
-                        else if ( (LA29_3==RULE_ID||(LA29_3>=113 && LA29_3<=114)) ) {
-                            alt29=2;
+                        else if ( (LA30_3==106) ) {
+                            alt30=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 29, 3, input);
+                                new NoViableAltException("", 30, 3, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 29, 2, input);
+                            new NoViableAltException("", 30, 2, input);
 
                         throw nvae;
                     }
                 }
-                else if ( (LA29_1==46) ) {
-                    int LA29_3 = input.LA(3);
+                else if ( (LA30_1==46) ) {
+                    int LA30_3 = input.LA(3);
 
-                    if ( (LA29_3==106) ) {
-                        alt29=1;
+                    if ( (LA30_3==RULE_ID||(LA30_3>=113 && LA30_3<=114)) ) {
+                        alt30=2;
                     }
-                    else if ( (LA29_3==RULE_ID||(LA29_3>=113 && LA29_3<=114)) ) {
-                        alt29=2;
+                    else if ( (LA30_3==106) ) {
+                        alt30=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 29, 3, input);
+                            new NoViableAltException("", 30, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 29, 1, input);
+                        new NoViableAltException("", 30, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 29, 0, input);
+                    new NoViableAltException("", 30, 0, input);
 
                 throw nvae;
             }
-            switch (alt29) {
+            switch (alt30) {
                 case 1 :
-                    // InternalRoom.g:3938:1: ( ruleInitialTransition )
+                    // InternalRoom.g:4013:1: ( ruleInitialTransition )
                     {
-                    // InternalRoom.g:3938:1: ( ruleInitialTransition )
-                    // InternalRoom.g:3939:1: ruleInitialTransition
+                    // InternalRoom.g:4013:1: ( ruleInitialTransition )
+                    // InternalRoom.g:4014:1: ruleInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11826,10 +12059,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3944:6: ( ruleNonInitialTransition )
+                    // InternalRoom.g:4019:6: ( ruleNonInitialTransition )
                     {
-                    // InternalRoom.g:3944:6: ( ruleNonInitialTransition )
-                    // InternalRoom.g:3945:1: ruleNonInitialTransition
+                    // InternalRoom.g:4019:6: ( ruleNonInitialTransition )
+                    // InternalRoom.g:4020:1: ruleNonInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11862,21 +12095,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NonInitialTransition__Alternatives"
-    // InternalRoom.g:3955:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );
+    // InternalRoom.g:4030:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );
     public final void rule__NonInitialTransition__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3959:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) )
-            int alt30=3;
-            alt30 = dfa30.predict(input);
-            switch (alt30) {
+            // InternalRoom.g:4034:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) )
+            int alt31=3;
+            alt31 = dfa31.predict(input);
+            switch (alt31) {
                 case 1 :
-                    // InternalRoom.g:3960:1: ( ruleTransitionChainStartTransition )
+                    // InternalRoom.g:4035:1: ( ruleTransitionChainStartTransition )
                     {
-                    // InternalRoom.g:3960:1: ( ruleTransitionChainStartTransition )
-                    // InternalRoom.g:3961:1: ruleTransitionChainStartTransition
+                    // InternalRoom.g:4035:1: ( ruleTransitionChainStartTransition )
+                    // InternalRoom.g:4036:1: ruleTransitionChainStartTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11892,10 +12125,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3966:6: ( ruleContinuationTransition )
+                    // InternalRoom.g:4041:6: ( ruleContinuationTransition )
                     {
-                    // InternalRoom.g:3966:6: ( ruleContinuationTransition )
-                    // InternalRoom.g:3967:1: ruleContinuationTransition
+                    // InternalRoom.g:4041:6: ( ruleContinuationTransition )
+                    // InternalRoom.g:4042:1: ruleContinuationTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11911,10 +12144,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3972:6: ( ruleCPBranchTransition )
+                    // InternalRoom.g:4047:6: ( ruleCPBranchTransition )
                     {
-                    // InternalRoom.g:3972:6: ( ruleCPBranchTransition )
-                    // InternalRoom.g:3973:1: ruleCPBranchTransition
+                    // InternalRoom.g:4047:6: ( ruleCPBranchTransition )
+                    // InternalRoom.g:4048:1: ruleCPBranchTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11947,21 +12180,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionChainStartTransition__Alternatives"
-    // InternalRoom.g:3983:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );
+    // InternalRoom.g:4058:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );
     public final void rule__TransitionChainStartTransition__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:3987:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) )
-            int alt31=2;
-            alt31 = dfa31.predict(input);
-            switch (alt31) {
+            // InternalRoom.g:4062:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) )
+            int alt32=2;
+            alt32 = dfa32.predict(input);
+            switch (alt32) {
                 case 1 :
-                    // InternalRoom.g:3988:1: ( ruleTriggeredTransition )
+                    // InternalRoom.g:4063:1: ( ruleTriggeredTransition )
                     {
-                    // InternalRoom.g:3988:1: ( ruleTriggeredTransition )
-                    // InternalRoom.g:3989:1: ruleTriggeredTransition
+                    // InternalRoom.g:4063:1: ( ruleTriggeredTransition )
+                    // InternalRoom.g:4064:1: ruleTriggeredTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11977,10 +12210,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3994:6: ( ruleGuardedTransition )
+                    // InternalRoom.g:4069:6: ( ruleGuardedTransition )
                     {
-                    // InternalRoom.g:3994:6: ( ruleGuardedTransition )
-                    // InternalRoom.g:3995:1: ruleGuardedTransition
+                    // InternalRoom.g:4069:6: ( ruleGuardedTransition )
+                    // InternalRoom.g:4070:1: ruleGuardedTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12013,28 +12246,28 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionTerminal__Alternatives"
-    // InternalRoom.g:4005:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) );
+    // InternalRoom.g:4080:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) );
     public final void rule__TransitionTerminal__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4009:1: ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) )
-            int alt32=4;
+            // InternalRoom.g:4084:1: ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) )
+            int alt33=4;
             switch ( input.LA(1) ) {
             case RULE_ID:
                 {
-                int LA32_1 = input.LA(2);
+                int LA33_1 = input.LA(2);
 
-                if ( (LA32_1==EOF||(LA32_1>=44 && LA32_1<=45)||LA32_1==48||LA32_1==62||LA32_1==95||(LA32_1>=100 && LA32_1<=105)||LA32_1==112||LA32_1==131) ) {
-                    alt32=1;
+                if ( (LA33_1==53) ) {
+                    alt33=3;
                 }
-                else if ( (LA32_1==53) ) {
-                    alt32=3;
+                else if ( (LA33_1==EOF||(LA33_1>=44 && LA33_1<=45)||LA33_1==48||LA33_1==62||LA33_1==95||(LA33_1>=100 && LA33_1<=105)||LA33_1==112||LA33_1==131) ) {
+                    alt33=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 32, 1, input);
+                        new NoViableAltException("", 33, 1, input);
 
                     throw nvae;
                 }
@@ -12042,27 +12275,27 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case 113:
                 {
-                alt32=2;
+                alt33=2;
                 }
                 break;
             case 114:
                 {
-                alt32=4;
+                alt33=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 32, 0, input);
+                    new NoViableAltException("", 33, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt32) {
+            switch (alt33) {
                 case 1 :
-                    // InternalRoom.g:4010:1: ( ruleStateTerminal )
+                    // InternalRoom.g:4085:1: ( ruleStateTerminal )
                     {
-                    // InternalRoom.g:4010:1: ( ruleStateTerminal )
-                    // InternalRoom.g:4011:1: ruleStateTerminal
+                    // InternalRoom.g:4085:1: ( ruleStateTerminal )
+                    // InternalRoom.g:4086:1: ruleStateTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12078,10 +12311,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4016:6: ( ruleTrPointTerminal )
+                    // InternalRoom.g:4091:6: ( ruleTrPointTerminal )
                     {
-                    // InternalRoom.g:4016:6: ( ruleTrPointTerminal )
-                    // InternalRoom.g:4017:1: ruleTrPointTerminal
+                    // InternalRoom.g:4091:6: ( ruleTrPointTerminal )
+                    // InternalRoom.g:4092:1: ruleTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12097,10 +12330,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4022:6: ( ruleSubStateTrPointTerminal )
+                    // InternalRoom.g:4097:6: ( ruleSubStateTrPointTerminal )
                     {
-                    // InternalRoom.g:4022:6: ( ruleSubStateTrPointTerminal )
-                    // InternalRoom.g:4023:1: ruleSubStateTrPointTerminal
+                    // InternalRoom.g:4097:6: ( ruleSubStateTrPointTerminal )
+                    // InternalRoom.g:4098:1: ruleSubStateTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -12116,10 +12349,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4028:6: ( ruleChoicepointTerminal )
+                    // InternalRoom.g:4103:6: ( ruleChoicepointTerminal )
                     {
-                    // InternalRoom.g:4028:6: ( ruleChoicepointTerminal )
-                    // InternalRoom.g:4029:1: ruleChoicepointTerminal
+                    // InternalRoom.g:4103:6: ( ruleChoicepointTerminal )
+                    // InternalRoom.g:4104:1: ruleChoicepointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
                     pushFollow(FOLLOW_2);
@@ -12152,34 +12385,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SemanticsRule__Alternatives"
-    // InternalRoom.g:4039:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) );
+    // InternalRoom.g:4114:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) );
     public final void rule__SemanticsRule__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4043:1: ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) )
-            int alt33=2;
-            int LA33_0 = input.LA(1);
+            // InternalRoom.g:4118:1: ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) )
+            int alt34=2;
+            int LA34_0 = input.LA(1);
 
-            if ( (LA33_0==119) ) {
-                alt33=1;
+            if ( (LA34_0==119) ) {
+                alt34=1;
             }
-            else if ( (LA33_0==120) ) {
-                alt33=2;
+            else if ( (LA34_0==120) ) {
+                alt34=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 33, 0, input);
+                    new NoViableAltException("", 34, 0, input);
 
                 throw nvae;
             }
-            switch (alt33) {
+            switch (alt34) {
                 case 1 :
-                    // InternalRoom.g:4044:1: ( ruleInSemanticsRule )
+                    // InternalRoom.g:4119:1: ( ruleInSemanticsRule )
                     {
-                    // InternalRoom.g:4044:1: ( ruleInSemanticsRule )
-                    // InternalRoom.g:4045:1: ruleInSemanticsRule
+                    // InternalRoom.g:4119:1: ( ruleInSemanticsRule )
+                    // InternalRoom.g:4120:1: ruleInSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12195,10 +12428,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4050:6: ( ruleOutSemanticsRule )
+                    // InternalRoom.g:4125:6: ( ruleOutSemanticsRule )
                     {
-                    // InternalRoom.g:4050:6: ( ruleOutSemanticsRule )
-                    // InternalRoom.g:4051:1: ruleOutSemanticsRule
+                    // InternalRoom.g:4125:6: ( ruleOutSemanticsRule )
+                    // InternalRoom.g:4126:1: ruleOutSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12231,38 +12464,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Alternatives_3_1"
-    // InternalRoom.g:4061:1: rule__InSemanticsRule__Alternatives_3_1 : ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) );
+    // InternalRoom.g:4136:1: rule__InSemanticsRule__Alternatives_3_1 : ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) );
     public final void rule__InSemanticsRule__Alternatives_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4065:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) )
-            int alt34=2;
-            int LA34_0 = input.LA(1);
+            // InternalRoom.g:4140:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) )
+            int alt35=2;
+            int LA35_0 = input.LA(1);
 
-            if ( ((LA34_0>=119 && LA34_0<=120)) ) {
-                alt34=1;
+            if ( ((LA35_0>=119 && LA35_0<=120)) ) {
+                alt35=1;
             }
-            else if ( (LA34_0==50) ) {
-                alt34=2;
+            else if ( (LA35_0==50) ) {
+                alt35=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 34, 0, input);
+                    new NoViableAltException("", 35, 0, input);
 
                 throw nvae;
             }
-            switch (alt34) {
+            switch (alt35) {
                 case 1 :
-                    // InternalRoom.g:4066:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4141:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
                     {
-                    // InternalRoom.g:4066:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
-                    // InternalRoom.g:4067:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4141:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4142:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
                     {
                      before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); 
-                    // InternalRoom.g:4068:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
-                    // InternalRoom.g:4068:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0
+                    // InternalRoom.g:4143:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4143:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -12280,14 +12513,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4072:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4147:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
                     {
-                    // InternalRoom.g:4072:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
-                    // InternalRoom.g:4073:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4147:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4148:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
                     {
                      before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); 
-                    // InternalRoom.g:4074:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
-                    // InternalRoom.g:4074:2: rule__InSemanticsRule__Group_3_1_1__0
+                    // InternalRoom.g:4149:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4149:2: rule__InSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3_1_1__0();
@@ -12322,38 +12555,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Alternatives_3_1"
-    // InternalRoom.g:4083:1: rule__OutSemanticsRule__Alternatives_3_1 : ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) );
+    // InternalRoom.g:4158:1: rule__OutSemanticsRule__Alternatives_3_1 : ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) );
     public final void rule__OutSemanticsRule__Alternatives_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4087:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) )
-            int alt35=2;
-            int LA35_0 = input.LA(1);
+            // InternalRoom.g:4162:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) )
+            int alt36=2;
+            int LA36_0 = input.LA(1);
 
-            if ( ((LA35_0>=119 && LA35_0<=120)) ) {
-                alt35=1;
+            if ( ((LA36_0>=119 && LA36_0<=120)) ) {
+                alt36=1;
             }
-            else if ( (LA35_0==50) ) {
-                alt35=2;
+            else if ( (LA36_0==50) ) {
+                alt36=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 35, 0, input);
+                    new NoViableAltException("", 36, 0, input);
 
                 throw nvae;
             }
-            switch (alt35) {
+            switch (alt36) {
                 case 1 :
-                    // InternalRoom.g:4088:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4163:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
                     {
-                    // InternalRoom.g:4088:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
-                    // InternalRoom.g:4089:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4163:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4164:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
                     {
                      before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); 
-                    // InternalRoom.g:4090:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
-                    // InternalRoom.g:4090:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
+                    // InternalRoom.g:4165:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4165:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -12371,14 +12604,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4094:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4169:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
                     {
-                    // InternalRoom.g:4094:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
-                    // InternalRoom.g:4095:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4169:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4170:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
                     {
                      before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); 
-                    // InternalRoom.g:4096:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
-                    // InternalRoom.g:4096:2: rule__OutSemanticsRule__Group_3_1_1__0
+                    // InternalRoom.g:4171:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4171:2: rule__OutSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3_1_1__0();
@@ -12413,38 +12646,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Alternatives_6"
-    // InternalRoom.g:4105:1: rule__AnnotationType__Alternatives_6 : ( ( ( rule__AnnotationType__TargetsAssignment_6_0 ) ) | ( ( rule__AnnotationType__Group_6_1__0 ) ) );
+    // InternalRoom.g:4180:1: rule__AnnotationType__Alternatives_6 : ( ( ( rule__AnnotationType__TargetsAssignment_6_0 ) ) | ( ( rule__AnnotationType__Group_6_1__0 ) ) );
     public final void rule__AnnotationType__Alternatives_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4109:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_0 ) ) | ( ( rule__AnnotationType__Group_6_1__0 ) ) )
-            int alt36=2;
-            int LA36_0 = input.LA(1);
+            // InternalRoom.g:4184:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_0 ) ) | ( ( rule__AnnotationType__Group_6_1__0 ) ) )
+            int alt37=2;
+            int LA37_0 = input.LA(1);
 
-            if ( ((LA36_0>=17 && LA36_0<=25)) ) {
-                alt36=1;
+            if ( ((LA37_0>=17 && LA37_0<=25)) ) {
+                alt37=1;
             }
-            else if ( (LA36_0==44) ) {
-                alt36=2;
+            else if ( (LA37_0==44) ) {
+                alt37=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 36, 0, input);
+                    new NoViableAltException("", 37, 0, input);
 
                 throw nvae;
             }
-            switch (alt36) {
+            switch (alt37) {
                 case 1 :
-                    // InternalRoom.g:4110:1: ( ( rule__AnnotationType__TargetsAssignment_6_0 ) )
+                    // InternalRoom.g:4185:1: ( ( rule__AnnotationType__TargetsAssignment_6_0 ) )
                     {
-                    // InternalRoom.g:4110:1: ( ( rule__AnnotationType__TargetsAssignment_6_0 ) )
-                    // InternalRoom.g:4111:1: ( rule__AnnotationType__TargetsAssignment_6_0 )
+                    // InternalRoom.g:4185:1: ( ( rule__AnnotationType__TargetsAssignment_6_0 ) )
+                    // InternalRoom.g:4186:1: ( rule__AnnotationType__TargetsAssignment_6_0 )
                     {
                      before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_0()); 
-                    // InternalRoom.g:4112:1: ( rule__AnnotationType__TargetsAssignment_6_0 )
-                    // InternalRoom.g:4112:2: rule__AnnotationType__TargetsAssignment_6_0
+                    // InternalRoom.g:4187:1: ( rule__AnnotationType__TargetsAssignment_6_0 )
+                    // InternalRoom.g:4187:2: rule__AnnotationType__TargetsAssignment_6_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__TargetsAssignment_6_0();
@@ -12462,14 +12695,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4116:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
+                    // InternalRoom.g:4191:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
                     {
-                    // InternalRoom.g:4116:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
-                    // InternalRoom.g:4117:1: ( rule__AnnotationType__Group_6_1__0 )
+                    // InternalRoom.g:4191:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
+                    // InternalRoom.g:4192:1: ( rule__AnnotationType__Group_6_1__0 )
                     {
                      before(grammarAccess.getAnnotationTypeAccess().getGroup_6_1()); 
-                    // InternalRoom.g:4118:1: ( rule__AnnotationType__Group_6_1__0 )
-                    // InternalRoom.g:4118:2: rule__AnnotationType__Group_6_1__0
+                    // InternalRoom.g:4193:1: ( rule__AnnotationType__Group_6_1__0 )
+                    // InternalRoom.g:4193:2: rule__AnnotationType__Group_6_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__Group_6_1__0();
@@ -12504,120 +12737,120 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationAttribute__Alternatives"
-    // InternalRoom.g:4127:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) );
+    // InternalRoom.g:4202:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) );
     public final void rule__AnnotationAttribute__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4131:1: ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) )
-            int alt37=2;
-            int LA37_0 = input.LA(1);
+            // InternalRoom.g:4206:1: ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) )
+            int alt38=2;
+            int LA38_0 = input.LA(1);
 
-            if ( (LA37_0==37) ) {
-                int LA37_1 = input.LA(2);
+            if ( (LA38_0==37) ) {
+                int LA38_1 = input.LA(2);
 
-                if ( (LA37_1==124) ) {
-                    int LA37_3 = input.LA(3);
+                if ( (LA38_1==124) ) {
+                    int LA38_3 = input.LA(3);
 
-                    if ( (LA37_3==RULE_ID) ) {
-                        int LA37_4 = input.LA(4);
+                    if ( (LA38_3==RULE_ID) ) {
+                        int LA38_4 = input.LA(4);
 
-                        if ( (LA37_4==46) ) {
-                            int LA37_5 = input.LA(5);
+                        if ( (LA38_4==46) ) {
+                            int LA38_5 = input.LA(5);
 
-                            if ( ((LA37_5>=39 && LA37_5<=42)) ) {
-                                alt37=1;
+                            if ( (LA38_5==44) ) {
+                                alt38=2;
                             }
-                            else if ( (LA37_5==44) ) {
-                                alt37=2;
+                            else if ( ((LA38_5>=39 && LA38_5<=42)) ) {
+                                alt38=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 37, 5, input);
+                                    new NoViableAltException("", 38, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 37, 4, input);
+                                new NoViableAltException("", 38, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 37, 3, input);
+                            new NoViableAltException("", 38, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 37, 1, input);
+                        new NoViableAltException("", 38, 1, input);
 
                     throw nvae;
                 }
             }
-            else if ( (LA37_0==26) ) {
-                int LA37_2 = input.LA(2);
+            else if ( (LA38_0==26) ) {
+                int LA38_2 = input.LA(2);
 
-                if ( (LA37_2==124) ) {
-                    int LA37_3 = input.LA(3);
+                if ( (LA38_2==124) ) {
+                    int LA38_3 = input.LA(3);
 
-                    if ( (LA37_3==RULE_ID) ) {
-                        int LA37_4 = input.LA(4);
+                    if ( (LA38_3==RULE_ID) ) {
+                        int LA38_4 = input.LA(4);
 
-                        if ( (LA37_4==46) ) {
-                            int LA37_5 = input.LA(5);
+                        if ( (LA38_4==46) ) {
+                            int LA38_5 = input.LA(5);
 
-                            if ( ((LA37_5>=39 && LA37_5<=42)) ) {
-                                alt37=1;
+                            if ( (LA38_5==44) ) {
+                                alt38=2;
                             }
-                            else if ( (LA37_5==44) ) {
-                                alt37=2;
+                            else if ( ((LA38_5>=39 && LA38_5<=42)) ) {
+                                alt38=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 37, 5, input);
+                                    new NoViableAltException("", 38, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 37, 4, input);
+                                new NoViableAltException("", 38, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 37, 3, input);
+                            new NoViableAltException("", 38, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 37, 2, input);
+                        new NoViableAltException("", 38, 2, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 37, 0, input);
+                    new NoViableAltException("", 38, 0, input);
 
                 throw nvae;
             }
-            switch (alt37) {
+            switch (alt38) {
                 case 1 :
-                    // InternalRoom.g:4132:1: ( ruleSimpleAnnotationAttribute )
+                    // InternalRoom.g:4207:1: ( ruleSimpleAnnotationAttribute )
                     {
-                    // InternalRoom.g:4132:1: ( ruleSimpleAnnotationAttribute )
-                    // InternalRoom.g:4133:1: ruleSimpleAnnotationAttribute
+                    // InternalRoom.g:4207:1: ( ruleSimpleAnnotationAttribute )
+                    // InternalRoom.g:4208:1: ruleSimpleAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12633,10 +12866,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4138:6: ( ruleEnumAnnotationAttribute )
+                    // InternalRoom.g:4213:6: ( ruleEnumAnnotationAttribute )
                     {
-                    // InternalRoom.g:4138:6: ( ruleEnumAnnotationAttribute )
-                    // InternalRoom.g:4139:1: ruleEnumAnnotationAttribute
+                    // InternalRoom.g:4213:6: ( ruleEnumAnnotationAttribute )
+                    // InternalRoom.g:4214:1: ruleEnumAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12669,38 +12902,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Alternatives_0"
-    // InternalRoom.g:4149:1: rule__SimpleAnnotationAttribute__Alternatives_0 : ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
+    // InternalRoom.g:4224:1: rule__SimpleAnnotationAttribute__Alternatives_0 : ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
     public final void rule__SimpleAnnotationAttribute__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4153:1: ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
-            int alt38=2;
-            int LA38_0 = input.LA(1);
+            // InternalRoom.g:4228:1: ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
+            int alt39=2;
+            int LA39_0 = input.LA(1);
 
-            if ( (LA38_0==37) ) {
-                alt38=1;
+            if ( (LA39_0==37) ) {
+                alt39=1;
             }
-            else if ( (LA38_0==26) ) {
-                alt38=2;
+            else if ( (LA39_0==26) ) {
+                alt39=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 38, 0, input);
+                    new NoViableAltException("", 39, 0, input);
 
                 throw nvae;
             }
-            switch (alt38) {
+            switch (alt39) {
                 case 1 :
-                    // InternalRoom.g:4154:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4229:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
                     {
-                    // InternalRoom.g:4154:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
-                    // InternalRoom.g:4155:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4229:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4230:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
                     {
                      before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); 
-                    // InternalRoom.g:4156:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
-                    // InternalRoom.g:4156:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
+                    // InternalRoom.g:4231:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4231:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleAnnotationAttribute__OptionalAssignment_0_0();
@@ -12718,10 +12951,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4160:6: ( 'mandatory' )
+                    // InternalRoom.g:4235:6: ( 'mandatory' )
                     {
-                    // InternalRoom.g:4160:6: ( 'mandatory' )
-                    // InternalRoom.g:4161:1: 'mandatory'
+                    // InternalRoom.g:4235:6: ( 'mandatory' )
+                    // InternalRoom.g:4236:1: 'mandatory'
                     {
                      before(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,26,FOLLOW_2); 
@@ -12750,38 +12983,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Alternatives_0"
-    // InternalRoom.g:4173:1: rule__EnumAnnotationAttribute__Alternatives_0 : ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
+    // InternalRoom.g:4248:1: rule__EnumAnnotationAttribute__Alternatives_0 : ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) );
     public final void rule__EnumAnnotationAttribute__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4177:1: ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
-            int alt39=2;
-            int LA39_0 = input.LA(1);
+            // InternalRoom.g:4252:1: ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) )
+            int alt40=2;
+            int LA40_0 = input.LA(1);
 
-            if ( (LA39_0==37) ) {
-                alt39=1;
+            if ( (LA40_0==37) ) {
+                alt40=1;
             }
-            else if ( (LA39_0==26) ) {
-                alt39=2;
+            else if ( (LA40_0==26) ) {
+                alt40=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 39, 0, input);
+                    new NoViableAltException("", 40, 0, input);
 
                 throw nvae;
             }
-            switch (alt39) {
+            switch (alt40) {
                 case 1 :
-                    // InternalRoom.g:4178:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4253:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
                     {
-                    // InternalRoom.g:4178:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
-                    // InternalRoom.g:4179:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4253:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4254:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
                     {
                      before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); 
-                    // InternalRoom.g:4180:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
-                    // InternalRoom.g:4180:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0
+                    // InternalRoom.g:4255:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4255:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumAnnotationAttribute__OptionalAssignment_0_0();
@@ -12799,10 +13032,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4184:6: ( 'mandatory' )
+                    // InternalRoom.g:4259:6: ( 'mandatory' )
                     {
-                    // InternalRoom.g:4184:6: ( 'mandatory' )
-                    // InternalRoom.g:4185:1: 'mandatory'
+                    // InternalRoom.g:4259:6: ( 'mandatory' )
+                    // InternalRoom.g:4260:1: 'mandatory'
                     {
                      before(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,26,FOLLOW_2); 
@@ -12831,38 +13064,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Alternatives_1"
-    // InternalRoom.g:4197:1: rule__Import__Alternatives_1 : ( ( ( rule__Import__Group_1_0__0 ) ) | ( 'model' ) );
+    // InternalRoom.g:4272:1: rule__Import__Alternatives_1 : ( ( ( rule__Import__Group_1_0__0 ) ) | ( 'model' ) );
     public final void rule__Import__Alternatives_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4201:1: ( ( ( rule__Import__Group_1_0__0 ) ) | ( 'model' ) )
-            int alt40=2;
-            int LA40_0 = input.LA(1);
+            // InternalRoom.g:4276:1: ( ( ( rule__Import__Group_1_0__0 ) ) | ( 'model' ) )
+            int alt41=2;
+            int LA41_0 = input.LA(1);
 
-            if ( (LA40_0==RULE_ID) ) {
-                alt40=1;
+            if ( (LA41_0==RULE_ID) ) {
+                alt41=1;
             }
-            else if ( (LA40_0==27) ) {
-                alt40=2;
+            else if ( (LA41_0==27) ) {
+                alt41=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 40, 0, input);
+                    new NoViableAltException("", 41, 0, input);
 
                 throw nvae;
             }
-            switch (alt40) {
+            switch (alt41) {
                 case 1 :
-                    // InternalRoom.g:4202:1: ( ( rule__Import__Group_1_0__0 ) )
+                    // InternalRoom.g:4277:1: ( ( rule__Import__Group_1_0__0 ) )
                     {
-                    // InternalRoom.g:4202:1: ( ( rule__Import__Group_1_0__0 ) )
-                    // InternalRoom.g:4203:1: ( rule__Import__Group_1_0__0 )
+                    // InternalRoom.g:4277:1: ( ( rule__Import__Group_1_0__0 ) )
+                    // InternalRoom.g:4278:1: ( rule__Import__Group_1_0__0 )
                     {
                      before(grammarAccess.getImportAccess().getGroup_1_0()); 
-                    // InternalRoom.g:4204:1: ( rule__Import__Group_1_0__0 )
-                    // InternalRoom.g:4204:2: rule__Import__Group_1_0__0
+                    // InternalRoom.g:4279:1: ( rule__Import__Group_1_0__0 )
+                    // InternalRoom.g:4279:2: rule__Import__Group_1_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Import__Group_1_0__0();
@@ -12880,10 +13113,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4208:6: ( 'model' )
+                    // InternalRoom.g:4283:6: ( 'model' )
                     {
-                    // InternalRoom.g:4208:6: ( 'model' )
-                    // InternalRoom.g:4209:1: 'model'
+                    // InternalRoom.g:4283:6: ( 'model' )
+                    // InternalRoom.g:4284:1: 'model'
                     {
                      before(grammarAccess.getImportAccess().getModelKeyword_1_1()); 
                     match(input,27,FOLLOW_2); 
@@ -12912,19 +13145,19 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Literal__Alternatives"
-    // InternalRoom.g:4222:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) );
+    // InternalRoom.g:4297:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) );
     public final void rule__Literal__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4226:1: ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) )
-            int alt41=3;
+            // InternalRoom.g:4301:1: ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) )
+            int alt42=3;
             switch ( input.LA(1) ) {
             case 28:
             case 132:
                 {
-                alt41=1;
+                alt42=1;
                 }
                 break;
             case RULE_INT:
@@ -12932,27 +13165,27 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             case 29:
             case 30:
                 {
-                alt41=2;
+                alt42=2;
                 }
                 break;
             case RULE_STRING:
                 {
-                alt41=3;
+                alt42=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 41, 0, input);
+                    new NoViableAltException("", 42, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt41) {
+            switch (alt42) {
                 case 1 :
-                    // InternalRoom.g:4227:1: ( ruleBooleanLiteral )
+                    // InternalRoom.g:4302:1: ( ruleBooleanLiteral )
                     {
-                    // InternalRoom.g:4227:1: ( ruleBooleanLiteral )
-                    // InternalRoom.g:4228:1: ruleBooleanLiteral
+                    // InternalRoom.g:4302:1: ( ruleBooleanLiteral )
+                    // InternalRoom.g:4303:1: ruleBooleanLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12968,10 +13201,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4233:6: ( ruleNumberLiteral )
+                    // InternalRoom.g:4308:6: ( ruleNumberLiteral )
                     {
-                    // InternalRoom.g:4233:6: ( ruleNumberLiteral )
-                    // InternalRoom.g:4234:1: ruleNumberLiteral
+                    // InternalRoom.g:4308:6: ( ruleNumberLiteral )
+                    // InternalRoom.g:4309:1: ruleNumberLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12987,10 +13220,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4239:6: ( ruleStringLiteral )
+                    // InternalRoom.g:4314:6: ( ruleStringLiteral )
                     {
-                    // InternalRoom.g:4239:6: ( ruleStringLiteral )
-                    // InternalRoom.g:4240:1: ruleStringLiteral
+                    // InternalRoom.g:4314:6: ( ruleStringLiteral )
+                    // InternalRoom.g:4315:1: ruleStringLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -13023,34 +13256,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Alternatives_1"
-    // InternalRoom.g:4250:1: rule__BooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) );
+    // InternalRoom.g:4325:1: rule__BooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) );
     public final void rule__BooleanLiteral__Alternatives_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4254:1: ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) )
-            int alt42=2;
-            int LA42_0 = input.LA(1);
+            // InternalRoom.g:4329:1: ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) )
+            int alt43=2;
+            int LA43_0 = input.LA(1);
 
-            if ( (LA42_0==28) ) {
-                alt42=1;
+            if ( (LA43_0==28) ) {
+                alt43=1;
             }
-            else if ( (LA42_0==132) ) {
-                alt42=2;
+            else if ( (LA43_0==132) ) {
+                alt43=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 42, 0, input);
+                    new NoViableAltException("", 43, 0, input);
 
                 throw nvae;
             }
-            switch (alt42) {
+            switch (alt43) {
                 case 1 :
-                    // InternalRoom.g:4255:1: ( 'false' )
+                    // InternalRoom.g:4330:1: ( 'false' )
                     {
-                    // InternalRoom.g:4255:1: ( 'false' )
-                    // InternalRoom.g:4256:1: 'false'
+                    // InternalRoom.g:4330:1: ( 'false' )
+                    // InternalRoom.g:4331:1: 'false'
                     {
                      before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); 
                     match(input,28,FOLLOW_2); 
@@ -13062,14 +13295,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4263:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalRoom.g:4338:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
                     {
-                    // InternalRoom.g:4263:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
-                    // InternalRoom.g:4264:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalRoom.g:4338:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalRoom.g:4339:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
                     {
                      before(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); 
-                    // InternalRoom.g:4265:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
-                    // InternalRoom.g:4265:2: rule__BooleanLiteral__IsTrueAssignment_1_1
+                    // InternalRoom.g:4340:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalRoom.g:4340:2: rule__BooleanLiteral__IsTrueAssignment_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__BooleanLiteral__IsTrueAssignment_1_1();
@@ -13104,38 +13337,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NumberLiteral__Alternatives"
-    // InternalRoom.g:4274:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) );
+    // InternalRoom.g:4349:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) );
     public final void rule__NumberLiteral__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4278:1: ( ( ruleIntLiteral ) | ( ruleRealLiteral ) )
-            int alt43=2;
+            // InternalRoom.g:4353:1: ( ( ruleIntLiteral ) | ( ruleRealLiteral ) )
+            int alt44=2;
             switch ( input.LA(1) ) {
             case 29:
                 {
-                int LA43_1 = input.LA(2);
+                int LA44_1 = input.LA(2);
 
-                if ( (LA43_1==RULE_INT) ) {
-                    int LA43_3 = input.LA(3);
+                if ( (LA44_1==RULE_INT) ) {
+                    int LA44_3 = input.LA(3);
 
-                    if ( (LA43_3==87) ) {
-                        alt43=2;
+                    if ( (LA44_3==87) ) {
+                        alt44=2;
                     }
-                    else if ( (LA43_3==EOF||LA43_3==51||LA43_3==54) ) {
-                        alt43=1;
+                    else if ( (LA44_3==EOF||LA44_3==51||LA44_3==54) ) {
+                        alt44=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 43, 3, input);
+                            new NoViableAltException("", 44, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 43, 1, input);
+                        new NoViableAltException("", 44, 1, input);
 
                     throw nvae;
                 }
@@ -13143,27 +13376,27 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case 30:
                 {
-                int LA43_2 = input.LA(2);
+                int LA44_2 = input.LA(2);
 
-                if ( (LA43_2==RULE_INT) ) {
-                    int LA43_3 = input.LA(3);
+                if ( (LA44_2==RULE_INT) ) {
+                    int LA44_3 = input.LA(3);
 
-                    if ( (LA43_3==87) ) {
-                        alt43=2;
+                    if ( (LA44_3==87) ) {
+                        alt44=2;
                     }
-                    else if ( (LA43_3==EOF||LA43_3==51||LA43_3==54) ) {
-                        alt43=1;
+                    else if ( (LA44_3==EOF||LA44_3==51||LA44_3==54) ) {
+                        alt44=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 43, 3, input);
+                            new NoViableAltException("", 44, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 43, 2, input);
+                        new NoViableAltException("", 44, 2, input);
 
                     throw nvae;
                 }
@@ -13171,17 +13404,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_INT:
                 {
-                int LA43_3 = input.LA(2);
+                int LA44_3 = input.LA(2);
 
-                if ( (LA43_3==87) ) {
-                    alt43=2;
+                if ( (LA44_3==87) ) {
+                    alt44=2;
                 }
-                else if ( (LA43_3==EOF||LA43_3==51||LA43_3==54) ) {
-                    alt43=1;
+                else if ( (LA44_3==EOF||LA44_3==51||LA44_3==54) ) {
+                    alt44=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 43, 3, input);
+                        new NoViableAltException("", 44, 3, input);
 
                     throw nvae;
                 }
@@ -13189,22 +13422,22 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_HEX:
                 {
-                alt43=1;
+                alt44=1;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 43, 0, input);
+                    new NoViableAltException("", 44, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt43) {
+            switch (alt44) {
                 case 1 :
-                    // InternalRoom.g:4279:1: ( ruleIntLiteral )
+                    // InternalRoom.g:4354:1: ( ruleIntLiteral )
                     {
-                    // InternalRoom.g:4279:1: ( ruleIntLiteral )
-                    // InternalRoom.g:4280:1: ruleIntLiteral
+                    // InternalRoom.g:4354:1: ( ruleIntLiteral )
+                    // InternalRoom.g:4355:1: ruleIntLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -13220,10 +13453,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4285:6: ( ruleRealLiteral )
+                    // InternalRoom.g:4360:6: ( ruleRealLiteral )
                     {
-                    // InternalRoom.g:4285:6: ( ruleRealLiteral )
-                    // InternalRoom.g:4286:1: ruleRealLiteral
+                    // InternalRoom.g:4360:6: ( ruleRealLiteral )
+                    // InternalRoom.g:4361:1: ruleRealLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -13256,38 +13489,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Alternatives"
-    // InternalRoom.g:4296:1: rule__Integer__Alternatives : ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) );
+    // InternalRoom.g:4371:1: rule__Integer__Alternatives : ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) );
     public final void rule__Integer__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4300:1: ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) )
-            int alt44=2;
-            int LA44_0 = input.LA(1);
+            // InternalRoom.g:4375:1: ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) )
+            int alt45=2;
+            int LA45_0 = input.LA(1);
 
-            if ( (LA44_0==RULE_INT||(LA44_0>=29 && LA44_0<=30)) ) {
-                alt44=1;
+            if ( (LA45_0==RULE_INT||(LA45_0>=29 && LA45_0<=30)) ) {
+                alt45=1;
             }
-            else if ( (LA44_0==RULE_HEX) ) {
-                alt44=2;
+            else if ( (LA45_0==RULE_HEX) ) {
+                alt45=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 44, 0, input);
+                    new NoViableAltException("", 45, 0, input);
 
                 throw nvae;
             }
-            switch (alt44) {
+            switch (alt45) {
                 case 1 :
-                    // InternalRoom.g:4301:1: ( ( rule__Integer__Group_0__0 ) )
+                    // InternalRoom.g:4376:1: ( ( rule__Integer__Group_0__0 ) )
                     {
-                    // InternalRoom.g:4301:1: ( ( rule__Integer__Group_0__0 ) )
-                    // InternalRoom.g:4302:1: ( rule__Integer__Group_0__0 )
+                    // InternalRoom.g:4376:1: ( ( rule__Integer__Group_0__0 ) )
+                    // InternalRoom.g:4377:1: ( rule__Integer__Group_0__0 )
                     {
                      before(grammarAccess.getIntegerAccess().getGroup_0()); 
-                    // InternalRoom.g:4303:1: ( rule__Integer__Group_0__0 )
-                    // InternalRoom.g:4303:2: rule__Integer__Group_0__0
+                    // InternalRoom.g:4378:1: ( rule__Integer__Group_0__0 )
+                    // InternalRoom.g:4378:2: rule__Integer__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Group_0__0();
@@ -13305,10 +13538,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4307:6: ( RULE_HEX )
+                    // InternalRoom.g:4382:6: ( RULE_HEX )
                     {
-                    // InternalRoom.g:4307:6: ( RULE_HEX )
-                    // InternalRoom.g:4308:1: RULE_HEX
+                    // InternalRoom.g:4382:6: ( RULE_HEX )
+                    // InternalRoom.g:4383:1: RULE_HEX
                     {
                      before(grammarAccess.getIntegerAccess().getHEXTerminalRuleCall_1()); 
                     match(input,RULE_HEX,FOLLOW_2); 
@@ -13337,34 +13570,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Alternatives_0_0"
-    // InternalRoom.g:4318:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4393:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__Integer__Alternatives_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4322:1: ( ( '+' ) | ( '-' ) )
-            int alt45=2;
-            int LA45_0 = input.LA(1);
+            // InternalRoom.g:4397:1: ( ( '+' ) | ( '-' ) )
+            int alt46=2;
+            int LA46_0 = input.LA(1);
 
-            if ( (LA45_0==29) ) {
-                alt45=1;
+            if ( (LA46_0==29) ) {
+                alt46=1;
             }
-            else if ( (LA45_0==30) ) {
-                alt45=2;
+            else if ( (LA46_0==30) ) {
+                alt46=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 45, 0, input);
+                    new NoViableAltException("", 46, 0, input);
 
                 throw nvae;
             }
-            switch (alt45) {
+            switch (alt46) {
                 case 1 :
-                    // InternalRoom.g:4323:1: ( '+' )
+                    // InternalRoom.g:4398:1: ( '+' )
                     {
-                    // InternalRoom.g:4323:1: ( '+' )
-                    // InternalRoom.g:4324:1: '+'
+                    // InternalRoom.g:4398:1: ( '+' )
+                    // InternalRoom.g:4399:1: '+'
                     {
                      before(grammarAccess.getIntegerAccess().getPlusSignKeyword_0_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13376,10 +13609,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4331:6: ( '-' )
+                    // InternalRoom.g:4406:6: ( '-' )
                     {
-                    // InternalRoom.g:4331:6: ( '-' )
-                    // InternalRoom.g:4332:1: '-'
+                    // InternalRoom.g:4406:6: ( '-' )
+                    // InternalRoom.g:4407:1: '-'
                     {
                      before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13408,58 +13641,58 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Real__Alternatives"
-    // InternalRoom.g:4344:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) );
+    // InternalRoom.g:4419:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) );
     public final void rule__Real__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4348:1: ( ( ruleDecimal ) | ( ruleDecimalExp ) )
-            int alt46=2;
+            // InternalRoom.g:4423:1: ( ( ruleDecimal ) | ( ruleDecimalExp ) )
+            int alt47=2;
             switch ( input.LA(1) ) {
             case 29:
                 {
-                int LA46_1 = input.LA(2);
+                int LA47_1 = input.LA(2);
 
-                if ( (LA46_1==RULE_INT) ) {
-                    int LA46_3 = input.LA(3);
+                if ( (LA47_1==RULE_INT) ) {
+                    int LA47_3 = input.LA(3);
 
-                    if ( (LA46_3==87) ) {
-                        int LA46_4 = input.LA(4);
+                    if ( (LA47_3==87) ) {
+                        int LA47_4 = input.LA(4);
 
-                        if ( (LA46_4==RULE_INT) ) {
-                            int LA46_5 = input.LA(5);
+                        if ( (LA47_4==RULE_INT) ) {
+                            int LA47_5 = input.LA(5);
 
-                            if ( (LA46_5==EOF||LA46_5==51||LA46_5==54) ) {
-                                alt46=1;
+                            if ( ((LA47_5>=31 && LA47_5<=32)) ) {
+                                alt47=2;
                             }
-                            else if ( ((LA46_5>=31 && LA46_5<=32)) ) {
-                                alt46=2;
+                            else if ( (LA47_5==EOF||LA47_5==51||LA47_5==54) ) {
+                                alt47=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 46, 5, input);
+                                    new NoViableAltException("", 47, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 46, 4, input);
+                                new NoViableAltException("", 47, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 46, 3, input);
+                            new NoViableAltException("", 47, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 46, 1, input);
+                        new NoViableAltException("", 47, 1, input);
 
                     throw nvae;
                 }
@@ -13467,47 +13700,47 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case 30:
                 {
-                int LA46_2 = input.LA(2);
+                int LA47_2 = input.LA(2);
 
-                if ( (LA46_2==RULE_INT) ) {
-                    int LA46_3 = input.LA(3);
+                if ( (LA47_2==RULE_INT) ) {
+                    int LA47_3 = input.LA(3);
 
-                    if ( (LA46_3==87) ) {
-                        int LA46_4 = input.LA(4);
+                    if ( (LA47_3==87) ) {
+                        int LA47_4 = input.LA(4);
 
-                        if ( (LA46_4==RULE_INT) ) {
-                            int LA46_5 = input.LA(5);
+                        if ( (LA47_4==RULE_INT) ) {
+                            int LA47_5 = input.LA(5);
 
-                            if ( (LA46_5==EOF||LA46_5==51||LA46_5==54) ) {
-                                alt46=1;
+                            if ( ((LA47_5>=31 && LA47_5<=32)) ) {
+                                alt47=2;
                             }
-                            else if ( ((LA46_5>=31 && LA46_5<=32)) ) {
-                                alt46=2;
+                            else if ( (LA47_5==EOF||LA47_5==51||LA47_5==54) ) {
+                                alt47=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 46, 5, input);
+                                    new NoViableAltException("", 47, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 46, 4, input);
+                                new NoViableAltException("", 47, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 46, 3, input);
+                            new NoViableAltException("", 47, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 46, 2, input);
+                        new NoViableAltException("", 47, 2, input);
 
                     throw nvae;
                 }
@@ -13515,37 +13748,37 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             case RULE_INT:
                 {
-                int LA46_3 = input.LA(2);
+                int LA47_3 = input.LA(2);
 
-                if ( (LA46_3==87) ) {
-                    int LA46_4 = input.LA(3);
+                if ( (LA47_3==87) ) {
+                    int LA47_4 = input.LA(3);
 
-                    if ( (LA46_4==RULE_INT) ) {
-                        int LA46_5 = input.LA(4);
+                    if ( (LA47_4==RULE_INT) ) {
+                        int LA47_5 = input.LA(4);
 
-                        if ( (LA46_5==EOF||LA46_5==51||LA46_5==54) ) {
-                            alt46=1;
+                        if ( ((LA47_5>=31 && LA47_5<=32)) ) {
+                            alt47=2;
                         }
-                        else if ( ((LA46_5>=31 && LA46_5<=32)) ) {
-                            alt46=2;
+                        else if ( (LA47_5==EOF||LA47_5==51||LA47_5==54) ) {
+                            alt47=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 46, 5, input);
+                                new NoViableAltException("", 47, 5, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 46, 4, input);
+                            new NoViableAltException("", 47, 4, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 46, 3, input);
+                        new NoViableAltException("", 47, 3, input);
 
                     throw nvae;
                 }
@@ -13553,17 +13786,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 46, 0, input);
+                    new NoViableAltException("", 47, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt46) {
+            switch (alt47) {
                 case 1 :
-                    // InternalRoom.g:4349:1: ( ruleDecimal )
+                    // InternalRoom.g:4424:1: ( ruleDecimal )
                     {
-                    // InternalRoom.g:4349:1: ( ruleDecimal )
-                    // InternalRoom.g:4350:1: ruleDecimal
+                    // InternalRoom.g:4424:1: ( ruleDecimal )
+                    // InternalRoom.g:4425:1: ruleDecimal
                     {
                      before(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -13579,10 +13812,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4355:6: ( ruleDecimalExp )
+                    // InternalRoom.g:4430:6: ( ruleDecimalExp )
                     {
-                    // InternalRoom.g:4355:6: ( ruleDecimalExp )
-                    // InternalRoom.g:4356:1: ruleDecimalExp
+                    // InternalRoom.g:4430:6: ( ruleDecimalExp )
+                    // InternalRoom.g:4431:1: ruleDecimalExp
                     {
                      before(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -13615,34 +13848,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Alternatives_0"
-    // InternalRoom.g:4366:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4441:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__Decimal__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4370:1: ( ( '+' ) | ( '-' ) )
-            int alt47=2;
-            int LA47_0 = input.LA(1);
+            // InternalRoom.g:4445:1: ( ( '+' ) | ( '-' ) )
+            int alt48=2;
+            int LA48_0 = input.LA(1);
 
-            if ( (LA47_0==29) ) {
-                alt47=1;
+            if ( (LA48_0==29) ) {
+                alt48=1;
             }
-            else if ( (LA47_0==30) ) {
-                alt47=2;
+            else if ( (LA48_0==30) ) {
+                alt48=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 47, 0, input);
+                    new NoViableAltException("", 48, 0, input);
 
                 throw nvae;
             }
-            switch (alt47) {
+            switch (alt48) {
                 case 1 :
-                    // InternalRoom.g:4371:1: ( '+' )
+                    // InternalRoom.g:4446:1: ( '+' )
                     {
-                    // InternalRoom.g:4371:1: ( '+' )
-                    // InternalRoom.g:4372:1: '+'
+                    // InternalRoom.g:4446:1: ( '+' )
+                    // InternalRoom.g:4447:1: '+'
                     {
                      before(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13654,10 +13887,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4379:6: ( '-' )
+                    // InternalRoom.g:4454:6: ( '-' )
                     {
-                    // InternalRoom.g:4379:6: ( '-' )
-                    // InternalRoom.g:4380:1: '-'
+                    // InternalRoom.g:4454:6: ( '-' )
+                    // InternalRoom.g:4455:1: '-'
                     {
                      before(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13686,34 +13919,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_0"
-    // InternalRoom.g:4392:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4467:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) );
     public final void rule__DecimalExp__Alternatives_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4396:1: ( ( '+' ) | ( '-' ) )
-            int alt48=2;
-            int LA48_0 = input.LA(1);
+            // InternalRoom.g:4471:1: ( ( '+' ) | ( '-' ) )
+            int alt49=2;
+            int LA49_0 = input.LA(1);
 
-            if ( (LA48_0==29) ) {
-                alt48=1;
+            if ( (LA49_0==29) ) {
+                alt49=1;
             }
-            else if ( (LA48_0==30) ) {
-                alt48=2;
+            else if ( (LA49_0==30) ) {
+                alt49=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 48, 0, input);
+                    new NoViableAltException("", 49, 0, input);
 
                 throw nvae;
             }
-            switch (alt48) {
+            switch (alt49) {
                 case 1 :
-                    // InternalRoom.g:4397:1: ( '+' )
+                    // InternalRoom.g:4472:1: ( '+' )
                     {
-                    // InternalRoom.g:4397:1: ( '+' )
-                    // InternalRoom.g:4398:1: '+'
+                    // InternalRoom.g:4472:1: ( '+' )
+                    // InternalRoom.g:4473:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13725,10 +13958,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4405:6: ( '-' )
+                    // InternalRoom.g:4480:6: ( '-' )
                     {
-                    // InternalRoom.g:4405:6: ( '-' )
-                    // InternalRoom.g:4406:1: '-'
+                    // InternalRoom.g:4480:6: ( '-' )
+                    // InternalRoom.g:4481:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13757,34 +13990,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_4"
-    // InternalRoom.g:4418:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) );
+    // InternalRoom.g:4493:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) );
     public final void rule__DecimalExp__Alternatives_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4422:1: ( ( 'e' ) | ( 'E' ) )
-            int alt49=2;
-            int LA49_0 = input.LA(1);
+            // InternalRoom.g:4497:1: ( ( 'e' ) | ( 'E' ) )
+            int alt50=2;
+            int LA50_0 = input.LA(1);
 
-            if ( (LA49_0==31) ) {
-                alt49=1;
+            if ( (LA50_0==31) ) {
+                alt50=1;
             }
-            else if ( (LA49_0==32) ) {
-                alt49=2;
+            else if ( (LA50_0==32) ) {
+                alt50=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 49, 0, input);
+                    new NoViableAltException("", 50, 0, input);
 
                 throw nvae;
             }
-            switch (alt49) {
+            switch (alt50) {
                 case 1 :
-                    // InternalRoom.g:4423:1: ( 'e' )
+                    // InternalRoom.g:4498:1: ( 'e' )
                     {
-                    // InternalRoom.g:4423:1: ( 'e' )
-                    // InternalRoom.g:4424:1: 'e'
+                    // InternalRoom.g:4498:1: ( 'e' )
+                    // InternalRoom.g:4499:1: 'e'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); 
                     match(input,31,FOLLOW_2); 
@@ -13796,10 +14029,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4431:6: ( 'E' )
+                    // InternalRoom.g:4506:6: ( 'E' )
                     {
-                    // InternalRoom.g:4431:6: ( 'E' )
-                    // InternalRoom.g:4432:1: 'E'
+                    // InternalRoom.g:4506:6: ( 'E' )
+                    // InternalRoom.g:4507:1: 'E'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); 
                     match(input,32,FOLLOW_2); 
@@ -13828,34 +14061,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_5"
-    // InternalRoom.g:4444:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4519:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) );
     public final void rule__DecimalExp__Alternatives_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4448:1: ( ( '+' ) | ( '-' ) )
-            int alt50=2;
-            int LA50_0 = input.LA(1);
+            // InternalRoom.g:4523:1: ( ( '+' ) | ( '-' ) )
+            int alt51=2;
+            int LA51_0 = input.LA(1);
 
-            if ( (LA50_0==29) ) {
-                alt50=1;
+            if ( (LA51_0==29) ) {
+                alt51=1;
             }
-            else if ( (LA50_0==30) ) {
-                alt50=2;
+            else if ( (LA51_0==30) ) {
+                alt51=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 50, 0, input);
+                    new NoViableAltException("", 51, 0, input);
 
                 throw nvae;
             }
-            switch (alt50) {
+            switch (alt51) {
                 case 1 :
-                    // InternalRoom.g:4449:1: ( '+' )
+                    // InternalRoom.g:4524:1: ( '+' )
                     {
-                    // InternalRoom.g:4449:1: ( '+' )
-                    // InternalRoom.g:4450:1: '+'
+                    // InternalRoom.g:4524:1: ( '+' )
+                    // InternalRoom.g:4525:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_5_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13867,10 +14100,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4457:6: ( '-' )
+                    // InternalRoom.g:4532:6: ( '-' )
                     {
-                    // InternalRoom.g:4457:6: ( '-' )
-                    // InternalRoom.g:4458:1: '-'
+                    // InternalRoom.g:4532:6: ( '-' )
+                    // InternalRoom.g:4533:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_5_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13899,47 +14132,47 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CommunicationType__Alternatives"
-    // InternalRoom.g:4470:1: rule__CommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'sync' ) ) );
+    // InternalRoom.g:4545:1: rule__CommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'sync' ) ) );
     public final void rule__CommunicationType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4474:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'sync' ) ) )
-            int alt51=3;
+            // InternalRoom.g:4549:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'sync' ) ) )
+            int alt52=3;
             switch ( input.LA(1) ) {
             case 33:
                 {
-                alt51=1;
+                alt52=1;
                 }
                 break;
             case 34:
                 {
-                alt51=2;
+                alt52=2;
                 }
                 break;
             case 35:
                 {
-                alt51=3;
+                alt52=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 51, 0, input);
+                    new NoViableAltException("", 52, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt51) {
+            switch (alt52) {
                 case 1 :
-                    // InternalRoom.g:4475:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4550:1: ( ( 'eventdriven' ) )
                     {
-                    // InternalRoom.g:4475:1: ( ( 'eventdriven' ) )
-                    // InternalRoom.g:4476:1: ( 'eventdriven' )
+                    // InternalRoom.g:4550:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4551:1: ( 'eventdriven' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4477:1: ( 'eventdriven' )
-                    // InternalRoom.g:4477:3: 'eventdriven'
+                    // InternalRoom.g:4552:1: ( 'eventdriven' )
+                    // InternalRoom.g:4552:3: 'eventdriven'
                     {
                     match(input,33,FOLLOW_2); 
 
@@ -13953,14 +14186,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4482:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4557:6: ( ( 'datadriven' ) )
                     {
-                    // InternalRoom.g:4482:6: ( ( 'datadriven' ) )
-                    // InternalRoom.g:4483:1: ( 'datadriven' )
+                    // InternalRoom.g:4557:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4558:1: ( 'datadriven' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4484:1: ( 'datadriven' )
-                    // InternalRoom.g:4484:3: 'datadriven'
+                    // InternalRoom.g:4559:1: ( 'datadriven' )
+                    // InternalRoom.g:4559:3: 'datadriven'
                     {
                     match(input,34,FOLLOW_2); 
 
@@ -13974,14 +14207,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4489:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4564:6: ( ( 'sync' ) )
                     {
-                    // InternalRoom.g:4489:6: ( ( 'sync' ) )
-                    // InternalRoom.g:4490:1: ( 'sync' )
+                    // InternalRoom.g:4564:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4565:1: ( 'sync' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4491:1: ( 'sync' )
-                    // InternalRoom.g:4491:3: 'sync'
+                    // InternalRoom.g:4566:1: ( 'sync' )
+                    // InternalRoom.g:4566:3: 'sync'
                     {
                     match(input,35,FOLLOW_2); 
 
@@ -14012,38 +14245,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ReferenceType__Alternatives"
-    // InternalRoom.g:4501:1: rule__ReferenceType__Alternatives : ( ( ( 'fixed' ) ) | ( ( 'optional' ) ) );
+    // InternalRoom.g:4576:1: rule__ReferenceType__Alternatives : ( ( ( 'fixed' ) ) | ( ( 'optional' ) ) );
     public final void rule__ReferenceType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4505:1: ( ( ( 'fixed' ) ) | ( ( 'optional' ) ) )
-            int alt52=2;
-            int LA52_0 = input.LA(1);
+            // InternalRoom.g:4580:1: ( ( ( 'fixed' ) ) | ( ( 'optional' ) ) )
+            int alt53=2;
+            int LA53_0 = input.LA(1);
 
-            if ( (LA52_0==36) ) {
-                alt52=1;
+            if ( (LA53_0==36) ) {
+                alt53=1;
             }
-            else if ( (LA52_0==37) ) {
-                alt52=2;
+            else if ( (LA53_0==37) ) {
+                alt53=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 52, 0, input);
+                    new NoViableAltException("", 53, 0, input);
 
                 throw nvae;
             }
-            switch (alt52) {
+            switch (alt53) {
                 case 1 :
-                    // InternalRoom.g:4506:1: ( ( 'fixed' ) )
+                    // InternalRoom.g:4581:1: ( ( 'fixed' ) )
                     {
-                    // InternalRoom.g:4506:1: ( ( 'fixed' ) )
-                    // InternalRoom.g:4507:1: ( 'fixed' )
+                    // InternalRoom.g:4581:1: ( ( 'fixed' ) )
+                    // InternalRoom.g:4582:1: ( 'fixed' )
                     {
                      before(grammarAccess.getReferenceTypeAccess().getFIXEDEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4508:1: ( 'fixed' )
-                    // InternalRoom.g:4508:3: 'fixed'
+                    // InternalRoom.g:4583:1: ( 'fixed' )
+                    // InternalRoom.g:4583:3: 'fixed'
                     {
                     match(input,36,FOLLOW_2); 
 
@@ -14057,14 +14290,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4513:6: ( ( 'optional' ) )
+                    // InternalRoom.g:4588:6: ( ( 'optional' ) )
                     {
-                    // InternalRoom.g:4513:6: ( ( 'optional' ) )
-                    // InternalRoom.g:4514:1: ( 'optional' )
+                    // InternalRoom.g:4588:6: ( ( 'optional' ) )
+                    // InternalRoom.g:4589:1: ( 'optional' )
                     {
                      before(grammarAccess.getReferenceTypeAccess().getOPTIONALEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4515:1: ( 'optional' )
-                    // InternalRoom.g:4515:3: 'optional'
+                    // InternalRoom.g:4590:1: ( 'optional' )
+                    // InternalRoom.g:4590:3: 'optional'
                     {
                     match(input,37,FOLLOW_2); 
 
@@ -14095,52 +14328,52 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ComponentCommunicationType__Alternatives"
-    // InternalRoom.g:4526:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) );
+    // InternalRoom.g:4601:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) );
     public final void rule__ComponentCommunicationType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4530:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) )
-            int alt53=4;
+            // InternalRoom.g:4605:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) )
+            int alt54=4;
             switch ( input.LA(1) ) {
             case 33:
                 {
-                alt53=1;
+                alt54=1;
                 }
                 break;
             case 34:
                 {
-                alt53=2;
+                alt54=2;
                 }
                 break;
             case 38:
                 {
-                alt53=3;
+                alt54=3;
                 }
                 break;
             case 35:
                 {
-                alt53=4;
+                alt54=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 53, 0, input);
+                    new NoViableAltException("", 54, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt53) {
+            switch (alt54) {
                 case 1 :
-                    // InternalRoom.g:4531:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4606:1: ( ( 'eventdriven' ) )
                     {
-                    // InternalRoom.g:4531:1: ( ( 'eventdriven' ) )
-                    // InternalRoom.g:4532:1: ( 'eventdriven' )
+                    // InternalRoom.g:4606:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4607:1: ( 'eventdriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4533:1: ( 'eventdriven' )
-                    // InternalRoom.g:4533:3: 'eventdriven'
+                    // InternalRoom.g:4608:1: ( 'eventdriven' )
+                    // InternalRoom.g:4608:3: 'eventdriven'
                     {
                     match(input,33,FOLLOW_2); 
 
@@ -14154,14 +14387,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4538:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4613:6: ( ( 'datadriven' ) )
                     {
-                    // InternalRoom.g:4538:6: ( ( 'datadriven' ) )
-                    // InternalRoom.g:4539:1: ( 'datadriven' )
+                    // InternalRoom.g:4613:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4614:1: ( 'datadriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4540:1: ( 'datadriven' )
-                    // InternalRoom.g:4540:3: 'datadriven'
+                    // InternalRoom.g:4615:1: ( 'datadriven' )
+                    // InternalRoom.g:4615:3: 'datadriven'
                     {
                     match(input,34,FOLLOW_2); 
 
@@ -14175,14 +14408,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4545:6: ( ( 'async' ) )
+                    // InternalRoom.g:4620:6: ( ( 'async' ) )
                     {
-                    // InternalRoom.g:4545:6: ( ( 'async' ) )
-                    // InternalRoom.g:4546:1: ( 'async' )
+                    // InternalRoom.g:4620:6: ( ( 'async' ) )
+                    // InternalRoom.g:4621:1: ( 'async' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4547:1: ( 'async' )
-                    // InternalRoom.g:4547:3: 'async'
+                    // InternalRoom.g:4622:1: ( 'async' )
+                    // InternalRoom.g:4622:3: 'async'
                     {
                     match(input,38,FOLLOW_2); 
 
@@ -14196,14 +14429,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4552:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4627:6: ( ( 'sync' ) )
                     {
-                    // InternalRoom.g:4552:6: ( ( 'sync' ) )
-                    // InternalRoom.g:4553:1: ( 'sync' )
+                    // InternalRoom.g:4627:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4628:1: ( 'sync' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); 
-                    // InternalRoom.g:4554:1: ( 'sync' )
-                    // InternalRoom.g:4554:3: 'sync'
+                    // InternalRoom.g:4629:1: ( 'sync' )
+                    // InternalRoom.g:4629:3: 'sync'
                     {
                     match(input,35,FOLLOW_2); 
 
@@ -14234,52 +14467,52 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LiteralType__Alternatives"
-    // InternalRoom.g:4564:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) );
+    // InternalRoom.g:4639:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) );
     public final void rule__LiteralType__Alternatives() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4568:1: ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) )
-            int alt54=4;
+            // InternalRoom.g:4643:1: ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) )
+            int alt55=4;
             switch ( input.LA(1) ) {
             case 39:
                 {
-                alt54=1;
+                alt55=1;
                 }
                 break;
             case 40:
                 {
-                alt54=2;
+                alt55=2;
                 }
                 break;
             case 41:
                 {
-                alt54=3;
+                alt55=3;
                 }
                 break;
             case 42:
                 {
-                alt54=4;
+                alt55=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 54, 0, input);
+                    new NoViableAltException("", 55, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt54) {
+            switch (alt55) {
                 case 1 :
-                    // InternalRoom.g:4569:1: ( ( 'ptBoolean' ) )
+                    // InternalRoom.g:4644:1: ( ( 'ptBoolean' ) )
                     {
-                    // InternalRoom.g:4569:1: ( ( 'ptBoolean' ) )
-                    // InternalRoom.g:4570:1: ( 'ptBoolean' )
+                    // InternalRoom.g:4644:1: ( ( 'ptBoolean' ) )
+                    // InternalRoom.g:4645:1: ( 'ptBoolean' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4571:1: ( 'ptBoolean' )
-                    // InternalRoom.g:4571:3: 'ptBoolean'
+                    // InternalRoom.g:4646:1: ( 'ptBoolean' )
+                    // InternalRoom.g:4646:3: 'ptBoolean'
                     {
                     match(input,39,FOLLOW_2); 
 
@@ -14293,14 +14526,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4576:6: ( ( 'ptInteger' ) )
+                    // InternalRoom.g:4651:6: ( ( 'ptInteger' ) )
                     {
-                    // InternalRoom.g:4576:6: ( ( 'ptInteger' ) )
-                    // InternalRoom.g:4577:1: ( 'ptInteger' )
+                    // InternalRoom.g:4651:6: ( ( 'ptInteger' ) )
+                    // InternalRoom.g:4652:1: ( 'ptInteger' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4578:1: ( 'ptInteger' )
-                    // InternalRoom.g:4578:3: 'ptInteger'
+                    // InternalRoom.g:4653:1: ( 'ptInteger' )
+                    // InternalRoom.g:4653:3: 'ptInteger'
                     {
                     match(input,40,FOLLOW_2); 
 
@@ -14314,14 +14547,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4583:6: ( ( 'ptReal' ) )
+                    // InternalRoom.g:4658:6: ( ( 'ptReal' ) )
                     {
-                    // InternalRoom.g:4583:6: ( ( 'ptReal' ) )
-                    // InternalRoom.g:4584:1: ( 'ptReal' )
+                    // InternalRoom.g:4658:6: ( ( 'ptReal' ) )
+                    // InternalRoom.g:4659:1: ( 'ptReal' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4585:1: ( 'ptReal' )
-                    // InternalRoom.g:4585:3: 'ptReal'
+                    // InternalRoom.g:4660:1: ( 'ptReal' )
+                    // InternalRoom.g:4660:3: 'ptReal'
                     {
                     match(input,41,FOLLOW_2); 
 
@@ -14335,14 +14568,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4590:6: ( ( 'ptCharacter' ) )
+                    // InternalRoom.g:4665:6: ( ( 'ptCharacter' ) )
                     {
-                    // InternalRoom.g:4590:6: ( ( 'ptCharacter' ) )
-                    // InternalRoom.g:4591:1: ( 'ptCharacter' )
+                    // InternalRoom.g:4665:6: ( ( 'ptCharacter' ) )
+                    // InternalRoom.g:4666:1: ( 'ptCharacter' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); 
-                    // InternalRoom.g:4592:1: ( 'ptCharacter' )
-                    // InternalRoom.g:4592:3: 'ptCharacter'
+                    // InternalRoom.g:4667:1: ( 'ptCharacter' )
+                    // InternalRoom.g:4667:3: 'ptCharacter'
                     {
                     match(input,42,FOLLOW_2); 
 
@@ -14373,14 +14606,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__0"
-    // InternalRoom.g:4604:1: rule__RoomModel__Group__0 : rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1 ;
+    // InternalRoom.g:4679:1: rule__RoomModel__Group__0 : rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1 ;
     public final void rule__RoomModel__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4608:1: ( rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1 )
-            // InternalRoom.g:4609:2: rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1
+            // InternalRoom.g:4683:1: ( rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1 )
+            // InternalRoom.g:4684:2: rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RoomModel__Group__0__Impl();
@@ -14411,17 +14644,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__0__Impl"
-    // InternalRoom.g:4616:1: rule__RoomModel__Group__0__Impl : ( 'RoomModel' ) ;
+    // InternalRoom.g:4691:1: rule__RoomModel__Group__0__Impl : ( 'RoomModel' ) ;
     public final void rule__RoomModel__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4620:1: ( ( 'RoomModel' ) )
-            // InternalRoom.g:4621:1: ( 'RoomModel' )
+            // InternalRoom.g:4695:1: ( ( 'RoomModel' ) )
+            // InternalRoom.g:4696:1: ( 'RoomModel' )
             {
-            // InternalRoom.g:4621:1: ( 'RoomModel' )
-            // InternalRoom.g:4622:1: 'RoomModel'
+            // InternalRoom.g:4696:1: ( 'RoomModel' )
+            // InternalRoom.g:4697:1: 'RoomModel'
             {
              before(grammarAccess.getRoomModelAccess().getRoomModelKeyword_0()); 
             match(input,43,FOLLOW_2); 
@@ -14448,14 +14681,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__1"
-    // InternalRoom.g:4635:1: rule__RoomModel__Group__1 : rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2 ;
+    // InternalRoom.g:4710:1: rule__RoomModel__Group__1 : rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2 ;
     public final void rule__RoomModel__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4639:1: ( rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2 )
-            // InternalRoom.g:4640:2: rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2
+            // InternalRoom.g:4714:1: ( rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2 )
+            // InternalRoom.g:4715:2: rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RoomModel__Group__1__Impl();
@@ -14486,21 +14719,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__1__Impl"
-    // InternalRoom.g:4647:1: rule__RoomModel__Group__1__Impl : ( ( rule__RoomModel__NameAssignment_1 ) ) ;
+    // InternalRoom.g:4722:1: rule__RoomModel__Group__1__Impl : ( ( rule__RoomModel__NameAssignment_1 ) ) ;
     public final void rule__RoomModel__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4651:1: ( ( ( rule__RoomModel__NameAssignment_1 ) ) )
-            // InternalRoom.g:4652:1: ( ( rule__RoomModel__NameAssignment_1 ) )
+            // InternalRoom.g:4726:1: ( ( ( rule__RoomModel__NameAssignment_1 ) ) )
+            // InternalRoom.g:4727:1: ( ( rule__RoomModel__NameAssignment_1 ) )
             {
-            // InternalRoom.g:4652:1: ( ( rule__RoomModel__NameAssignment_1 ) )
-            // InternalRoom.g:4653:1: ( rule__RoomModel__NameAssignment_1 )
+            // InternalRoom.g:4727:1: ( ( rule__RoomModel__NameAssignment_1 ) )
+            // InternalRoom.g:4728:1: ( rule__RoomModel__NameAssignment_1 )
             {
              before(grammarAccess.getRoomModelAccess().getNameAssignment_1()); 
-            // InternalRoom.g:4654:1: ( rule__RoomModel__NameAssignment_1 )
-            // InternalRoom.g:4654:2: rule__RoomModel__NameAssignment_1
+            // InternalRoom.g:4729:1: ( rule__RoomModel__NameAssignment_1 )
+            // InternalRoom.g:4729:2: rule__RoomModel__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RoomModel__NameAssignment_1();
@@ -14533,14 +14766,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__2"
-    // InternalRoom.g:4664:1: rule__RoomModel__Group__2 : rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3 ;
+    // InternalRoom.g:4739:1: rule__RoomModel__Group__2 : rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3 ;
     public final void rule__RoomModel__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4668:1: ( rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3 )
-            // InternalRoom.g:4669:2: rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3
+            // InternalRoom.g:4743:1: ( rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3 )
+            // InternalRoom.g:4744:2: rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RoomModel__Group__2__Impl();
@@ -14571,29 +14804,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__2__Impl"
-    // InternalRoom.g:4676:1: rule__RoomModel__Group__2__Impl : ( ( rule__RoomModel__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:4751:1: rule__RoomModel__Group__2__Impl : ( ( rule__RoomModel__DocuAssignment_2 )? ) ;
     public final void rule__RoomModel__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4680:1: ( ( ( rule__RoomModel__DocuAssignment_2 )? ) )
-            // InternalRoom.g:4681:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
+            // InternalRoom.g:4755:1: ( ( ( rule__RoomModel__DocuAssignment_2 )? ) )
+            // InternalRoom.g:4756:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:4681:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
-            // InternalRoom.g:4682:1: ( rule__RoomModel__DocuAssignment_2 )?
+            // InternalRoom.g:4756:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
+            // InternalRoom.g:4757:1: ( rule__RoomModel__DocuAssignment_2 )?
             {
              before(grammarAccess.getRoomModelAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:4683:1: ( rule__RoomModel__DocuAssignment_2 )?
-            int alt55=2;
-            int LA55_0 = input.LA(1);
+            // InternalRoom.g:4758:1: ( rule__RoomModel__DocuAssignment_2 )?
+            int alt56=2;
+            int LA56_0 = input.LA(1);
 
-            if ( (LA55_0==62) ) {
-                alt55=1;
+            if ( (LA56_0==62) ) {
+                alt56=1;
             }
-            switch (alt55) {
+            switch (alt56) {
                 case 1 :
-                    // InternalRoom.g:4683:2: rule__RoomModel__DocuAssignment_2
+                    // InternalRoom.g:4758:2: rule__RoomModel__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__DocuAssignment_2();
@@ -14629,14 +14862,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__3"
-    // InternalRoom.g:4693:1: rule__RoomModel__Group__3 : rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4 ;
+    // InternalRoom.g:4768:1: rule__RoomModel__Group__3 : rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4 ;
     public final void rule__RoomModel__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4697:1: ( rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4 )
-            // InternalRoom.g:4698:2: rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4
+            // InternalRoom.g:4772:1: ( rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4 )
+            // InternalRoom.g:4773:2: rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__3__Impl();
@@ -14667,17 +14900,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__3__Impl"
-    // InternalRoom.g:4705:1: rule__RoomModel__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:4780:1: rule__RoomModel__Group__3__Impl : ( '{' ) ;
     public final void rule__RoomModel__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4709:1: ( ( '{' ) )
-            // InternalRoom.g:4710:1: ( '{' )
+            // InternalRoom.g:4784:1: ( ( '{' ) )
+            // InternalRoom.g:4785:1: ( '{' )
             {
-            // InternalRoom.g:4710:1: ( '{' )
-            // InternalRoom.g:4711:1: '{'
+            // InternalRoom.g:4785:1: ( '{' )
+            // InternalRoom.g:4786:1: '{'
             {
              before(grammarAccess.getRoomModelAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -14704,14 +14937,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__4"
-    // InternalRoom.g:4724:1: rule__RoomModel__Group__4 : rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5 ;
+    // InternalRoom.g:4799:1: rule__RoomModel__Group__4 : rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5 ;
     public final void rule__RoomModel__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4728:1: ( rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5 )
-            // InternalRoom.g:4729:2: rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5
+            // InternalRoom.g:4803:1: ( rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5 )
+            // InternalRoom.g:4804:2: rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__4__Impl();
@@ -14742,33 +14975,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__4__Impl"
-    // InternalRoom.g:4736:1: rule__RoomModel__Group__4__Impl : ( ( rule__RoomModel__ImportsAssignment_4 )* ) ;
+    // InternalRoom.g:4811:1: rule__RoomModel__Group__4__Impl : ( ( rule__RoomModel__ImportsAssignment_4 )* ) ;
     public final void rule__RoomModel__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4740:1: ( ( ( rule__RoomModel__ImportsAssignment_4 )* ) )
-            // InternalRoom.g:4741:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
+            // InternalRoom.g:4815:1: ( ( ( rule__RoomModel__ImportsAssignment_4 )* ) )
+            // InternalRoom.g:4816:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
             {
-            // InternalRoom.g:4741:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
-            // InternalRoom.g:4742:1: ( rule__RoomModel__ImportsAssignment_4 )*
+            // InternalRoom.g:4816:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
+            // InternalRoom.g:4817:1: ( rule__RoomModel__ImportsAssignment_4 )*
             {
              before(grammarAccess.getRoomModelAccess().getImportsAssignment_4()); 
-            // InternalRoom.g:4743:1: ( rule__RoomModel__ImportsAssignment_4 )*
-            loop56:
+            // InternalRoom.g:4818:1: ( rule__RoomModel__ImportsAssignment_4 )*
+            loop57:
             do {
-                int alt56=2;
-                int LA56_0 = input.LA(1);
+                int alt57=2;
+                int LA57_0 = input.LA(1);
 
-                if ( (LA56_0==125) ) {
-                    alt56=1;
+                if ( (LA57_0==125) ) {
+                    alt57=1;
                 }
 
 
-                switch (alt56) {
+                switch (alt57) {
             	case 1 :
-            	    // InternalRoom.g:4743:2: rule__RoomModel__ImportsAssignment_4
+            	    // InternalRoom.g:4818:2: rule__RoomModel__ImportsAssignment_4
             	    {
             	    pushFollow(FOLLOW_6);
             	    rule__RoomModel__ImportsAssignment_4();
@@ -14780,7 +15013,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop56;
+            	    break loop57;
                 }
             } while (true);
 
@@ -14807,14 +15040,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__5"
-    // InternalRoom.g:4753:1: rule__RoomModel__Group__5 : rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6 ;
+    // InternalRoom.g:4828:1: rule__RoomModel__Group__5 : rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6 ;
     public final void rule__RoomModel__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4757:1: ( rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6 )
-            // InternalRoom.g:4758:2: rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6
+            // InternalRoom.g:4832:1: ( rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6 )
+            // InternalRoom.g:4833:2: rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__5__Impl();
@@ -14845,33 +15078,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__5__Impl"
-    // InternalRoom.g:4765:1: rule__RoomModel__Group__5__Impl : ( ( rule__RoomModel__Alternatives_5 )* ) ;
+    // InternalRoom.g:4840:1: rule__RoomModel__Group__5__Impl : ( ( rule__RoomModel__Alternatives_5 )* ) ;
     public final void rule__RoomModel__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4769:1: ( ( ( rule__RoomModel__Alternatives_5 )* ) )
-            // InternalRoom.g:4770:1: ( ( rule__RoomModel__Alternatives_5 )* )
+            // InternalRoom.g:4844:1: ( ( ( rule__RoomModel__Alternatives_5 )* ) )
+            // InternalRoom.g:4845:1: ( ( rule__RoomModel__Alternatives_5 )* )
             {
-            // InternalRoom.g:4770:1: ( ( rule__RoomModel__Alternatives_5 )* )
-            // InternalRoom.g:4771:1: ( rule__RoomModel__Alternatives_5 )*
+            // InternalRoom.g:4845:1: ( ( rule__RoomModel__Alternatives_5 )* )
+            // InternalRoom.g:4846:1: ( rule__RoomModel__Alternatives_5 )*
             {
              before(grammarAccess.getRoomModelAccess().getAlternatives_5()); 
-            // InternalRoom.g:4772:1: ( rule__RoomModel__Alternatives_5 )*
-            loop57:
+            // InternalRoom.g:4847:1: ( rule__RoomModel__Alternatives_5 )*
+            loop58:
             do {
-                int alt57=2;
-                int LA57_0 = input.LA(1);
+                int alt58=2;
+                int LA58_0 = input.LA(1);
 
-                if ( ((LA57_0>=17 && LA57_0<=18)||(LA57_0>=20 && LA57_0<=23)||(LA57_0>=33 && LA57_0<=35)||LA57_0==38||LA57_0==47||LA57_0==52||LA57_0==56||LA57_0==122||LA57_0==130) ) {
-                    alt57=1;
+                if ( ((LA58_0>=17 && LA58_0<=18)||(LA58_0>=20 && LA58_0<=23)||(LA58_0>=33 && LA58_0<=35)||LA58_0==38||LA58_0==47||LA58_0==52||LA58_0==56||LA58_0==122||LA58_0==130) ) {
+                    alt58=1;
                 }
 
 
-                switch (alt57) {
+                switch (alt58) {
             	case 1 :
-            	    // InternalRoom.g:4772:2: rule__RoomModel__Alternatives_5
+            	    // InternalRoom.g:4847:2: rule__RoomModel__Alternatives_5
             	    {
             	    pushFollow(FOLLOW_7);
             	    rule__RoomModel__Alternatives_5();
@@ -14883,7 +15116,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop57;
+            	    break loop58;
                 }
             } while (true);
 
@@ -14910,14 +15143,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__6"
-    // InternalRoom.g:4782:1: rule__RoomModel__Group__6 : rule__RoomModel__Group__6__Impl ;
+    // InternalRoom.g:4857:1: rule__RoomModel__Group__6 : rule__RoomModel__Group__6__Impl ;
     public final void rule__RoomModel__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4786:1: ( rule__RoomModel__Group__6__Impl )
-            // InternalRoom.g:4787:2: rule__RoomModel__Group__6__Impl
+            // InternalRoom.g:4861:1: ( rule__RoomModel__Group__6__Impl )
+            // InternalRoom.g:4862:2: rule__RoomModel__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RoomModel__Group__6__Impl();
@@ -14943,17 +15176,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__6__Impl"
-    // InternalRoom.g:4793:1: rule__RoomModel__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:4868:1: rule__RoomModel__Group__6__Impl : ( '}' ) ;
     public final void rule__RoomModel__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4797:1: ( ( '}' ) )
-            // InternalRoom.g:4798:1: ( '}' )
+            // InternalRoom.g:4872:1: ( ( '}' ) )
+            // InternalRoom.g:4873:1: ( '}' )
             {
-            // InternalRoom.g:4798:1: ( '}' )
-            // InternalRoom.g:4799:1: '}'
+            // InternalRoom.g:4873:1: ( '}' )
+            // InternalRoom.g:4874:1: '}'
             {
              before(grammarAccess.getRoomModelAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -14980,14 +15213,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__0"
-    // InternalRoom.g:4826:1: rule__VarDecl__Group__0 : rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1 ;
+    // InternalRoom.g:4901:1: rule__VarDecl__Group__0 : rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1 ;
     public final void rule__VarDecl__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4830:1: ( rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1 )
-            // InternalRoom.g:4831:2: rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1
+            // InternalRoom.g:4905:1: ( rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1 )
+            // InternalRoom.g:4906:2: rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__VarDecl__Group__0__Impl();
@@ -15018,21 +15251,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__0__Impl"
-    // InternalRoom.g:4838:1: rule__VarDecl__Group__0__Impl : ( ( rule__VarDecl__NameAssignment_0 ) ) ;
+    // InternalRoom.g:4913:1: rule__VarDecl__Group__0__Impl : ( ( rule__VarDecl__NameAssignment_0 ) ) ;
     public final void rule__VarDecl__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4842:1: ( ( ( rule__VarDecl__NameAssignment_0 ) ) )
-            // InternalRoom.g:4843:1: ( ( rule__VarDecl__NameAssignment_0 ) )
+            // InternalRoom.g:4917:1: ( ( ( rule__VarDecl__NameAssignment_0 ) ) )
+            // InternalRoom.g:4918:1: ( ( rule__VarDecl__NameAssignment_0 ) )
             {
-            // InternalRoom.g:4843:1: ( ( rule__VarDecl__NameAssignment_0 ) )
-            // InternalRoom.g:4844:1: ( rule__VarDecl__NameAssignment_0 )
+            // InternalRoom.g:4918:1: ( ( rule__VarDecl__NameAssignment_0 ) )
+            // InternalRoom.g:4919:1: ( rule__VarDecl__NameAssignment_0 )
             {
              before(grammarAccess.getVarDeclAccess().getNameAssignment_0()); 
-            // InternalRoom.g:4845:1: ( rule__VarDecl__NameAssignment_0 )
-            // InternalRoom.g:4845:2: rule__VarDecl__NameAssignment_0
+            // InternalRoom.g:4920:1: ( rule__VarDecl__NameAssignment_0 )
+            // InternalRoom.g:4920:2: rule__VarDecl__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__NameAssignment_0();
@@ -15065,14 +15298,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__1"
-    // InternalRoom.g:4855:1: rule__VarDecl__Group__1 : rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2 ;
+    // InternalRoom.g:4930:1: rule__VarDecl__Group__1 : rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2 ;
     public final void rule__VarDecl__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4859:1: ( rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2 )
-            // InternalRoom.g:4860:2: rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2
+            // InternalRoom.g:4934:1: ( rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2 )
+            // InternalRoom.g:4935:2: rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__VarDecl__Group__1__Impl();
@@ -15103,17 +15336,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__1__Impl"
-    // InternalRoom.g:4867:1: rule__VarDecl__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:4942:1: rule__VarDecl__Group__1__Impl : ( ':' ) ;
     public final void rule__VarDecl__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4871:1: ( ( ':' ) )
-            // InternalRoom.g:4872:1: ( ':' )
+            // InternalRoom.g:4946:1: ( ( ':' ) )
+            // InternalRoom.g:4947:1: ( ':' )
             {
-            // InternalRoom.g:4872:1: ( ':' )
-            // InternalRoom.g:4873:1: ':'
+            // InternalRoom.g:4947:1: ( ':' )
+            // InternalRoom.g:4948:1: ':'
             {
              before(grammarAccess.getVarDeclAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -15140,14 +15373,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__2"
-    // InternalRoom.g:4886:1: rule__VarDecl__Group__2 : rule__VarDecl__Group__2__Impl ;
+    // InternalRoom.g:4961:1: rule__VarDecl__Group__2 : rule__VarDecl__Group__2__Impl ;
     public final void rule__VarDecl__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4890:1: ( rule__VarDecl__Group__2__Impl )
-            // InternalRoom.g:4891:2: rule__VarDecl__Group__2__Impl
+            // InternalRoom.g:4965:1: ( rule__VarDecl__Group__2__Impl )
+            // InternalRoom.g:4966:2: rule__VarDecl__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__Group__2__Impl();
@@ -15173,21 +15406,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__2__Impl"
-    // InternalRoom.g:4897:1: rule__VarDecl__Group__2__Impl : ( ( rule__VarDecl__RefTypeAssignment_2 ) ) ;
+    // InternalRoom.g:4972:1: rule__VarDecl__Group__2__Impl : ( ( rule__VarDecl__RefTypeAssignment_2 ) ) ;
     public final void rule__VarDecl__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4901:1: ( ( ( rule__VarDecl__RefTypeAssignment_2 ) ) )
-            // InternalRoom.g:4902:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
+            // InternalRoom.g:4976:1: ( ( ( rule__VarDecl__RefTypeAssignment_2 ) ) )
+            // InternalRoom.g:4977:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
             {
-            // InternalRoom.g:4902:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
-            // InternalRoom.g:4903:1: ( rule__VarDecl__RefTypeAssignment_2 )
+            // InternalRoom.g:4977:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
+            // InternalRoom.g:4978:1: ( rule__VarDecl__RefTypeAssignment_2 )
             {
              before(grammarAccess.getVarDeclAccess().getRefTypeAssignment_2()); 
-            // InternalRoom.g:4904:1: ( rule__VarDecl__RefTypeAssignment_2 )
-            // InternalRoom.g:4904:2: rule__VarDecl__RefTypeAssignment_2
+            // InternalRoom.g:4979:1: ( rule__VarDecl__RefTypeAssignment_2 )
+            // InternalRoom.g:4979:2: rule__VarDecl__RefTypeAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__RefTypeAssignment_2();
@@ -15219,15 +15452,350 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__VarDecl__Group__2__Impl"
 
 
+    // $ANTLR start "rule__MessageData__Group__0"
+    // InternalRoom.g:4995:1: rule__MessageData__Group__0 : rule__MessageData__Group__0__Impl rule__MessageData__Group__1 ;
+    public final void rule__MessageData__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:4999:1: ( rule__MessageData__Group__0__Impl rule__MessageData__Group__1 )
+            // InternalRoom.g:5000:2: rule__MessageData__Group__0__Impl rule__MessageData__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__MessageData__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MessageData__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group__0"
+
+
+    // $ANTLR start "rule__MessageData__Group__0__Impl"
+    // InternalRoom.g:5007:1: rule__MessageData__Group__0__Impl : ( ( rule__MessageData__Group_0__0 )? ) ;
+    public final void rule__MessageData__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5011:1: ( ( ( rule__MessageData__Group_0__0 )? ) )
+            // InternalRoom.g:5012:1: ( ( rule__MessageData__Group_0__0 )? )
+            {
+            // InternalRoom.g:5012:1: ( ( rule__MessageData__Group_0__0 )? )
+            // InternalRoom.g:5013:1: ( rule__MessageData__Group_0__0 )?
+            {
+             before(grammarAccess.getMessageDataAccess().getGroup_0()); 
+            // InternalRoom.g:5014:1: ( rule__MessageData__Group_0__0 )?
+            int alt59=2;
+            int LA59_0 = input.LA(1);
+
+            if ( (LA59_0==RULE_ID) ) {
+                int LA59_1 = input.LA(2);
+
+                if ( (LA59_1==46) ) {
+                    alt59=1;
+                }
+            }
+            switch (alt59) {
+                case 1 :
+                    // InternalRoom.g:5014:2: rule__MessageData__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MessageData__Group_0__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMessageDataAccess().getGroup_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group__0__Impl"
+
+
+    // $ANTLR start "rule__MessageData__Group__1"
+    // InternalRoom.g:5024:1: rule__MessageData__Group__1 : rule__MessageData__Group__1__Impl ;
+    public final void rule__MessageData__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5028:1: ( rule__MessageData__Group__1__Impl )
+            // InternalRoom.g:5029:2: rule__MessageData__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MessageData__Group__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group__1"
+
+
+    // $ANTLR start "rule__MessageData__Group__1__Impl"
+    // InternalRoom.g:5035:1: rule__MessageData__Group__1__Impl : ( ( rule__MessageData__RefTypeAssignment_1 ) ) ;
+    public final void rule__MessageData__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5039:1: ( ( ( rule__MessageData__RefTypeAssignment_1 ) ) )
+            // InternalRoom.g:5040:1: ( ( rule__MessageData__RefTypeAssignment_1 ) )
+            {
+            // InternalRoom.g:5040:1: ( ( rule__MessageData__RefTypeAssignment_1 ) )
+            // InternalRoom.g:5041:1: ( rule__MessageData__RefTypeAssignment_1 )
+            {
+             before(grammarAccess.getMessageDataAccess().getRefTypeAssignment_1()); 
+            // InternalRoom.g:5042:1: ( rule__MessageData__RefTypeAssignment_1 )
+            // InternalRoom.g:5042:2: rule__MessageData__RefTypeAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__MessageData__RefTypeAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMessageDataAccess().getRefTypeAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group__1__Impl"
+
+
+    // $ANTLR start "rule__MessageData__Group_0__0"
+    // InternalRoom.g:5056:1: rule__MessageData__Group_0__0 : rule__MessageData__Group_0__0__Impl rule__MessageData__Group_0__1 ;
+    public final void rule__MessageData__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5060:1: ( rule__MessageData__Group_0__0__Impl rule__MessageData__Group_0__1 )
+            // InternalRoom.g:5061:2: rule__MessageData__Group_0__0__Impl rule__MessageData__Group_0__1
+            {
+            pushFollow(FOLLOW_8);
+            rule__MessageData__Group_0__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MessageData__Group_0__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group_0__0"
+
+
+    // $ANTLR start "rule__MessageData__Group_0__0__Impl"
+    // InternalRoom.g:5068:1: rule__MessageData__Group_0__0__Impl : ( ( rule__MessageData__DeprecatedNameAssignment_0_0 ) ) ;
+    public final void rule__MessageData__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5072:1: ( ( ( rule__MessageData__DeprecatedNameAssignment_0_0 ) ) )
+            // InternalRoom.g:5073:1: ( ( rule__MessageData__DeprecatedNameAssignment_0_0 ) )
+            {
+            // InternalRoom.g:5073:1: ( ( rule__MessageData__DeprecatedNameAssignment_0_0 ) )
+            // InternalRoom.g:5074:1: ( rule__MessageData__DeprecatedNameAssignment_0_0 )
+            {
+             before(grammarAccess.getMessageDataAccess().getDeprecatedNameAssignment_0_0()); 
+            // InternalRoom.g:5075:1: ( rule__MessageData__DeprecatedNameAssignment_0_0 )
+            // InternalRoom.g:5075:2: rule__MessageData__DeprecatedNameAssignment_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__MessageData__DeprecatedNameAssignment_0_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMessageDataAccess().getDeprecatedNameAssignment_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__MessageData__Group_0__1"
+    // InternalRoom.g:5085:1: rule__MessageData__Group_0__1 : rule__MessageData__Group_0__1__Impl ;
+    public final void rule__MessageData__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5089:1: ( rule__MessageData__Group_0__1__Impl )
+            // InternalRoom.g:5090:2: rule__MessageData__Group_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MessageData__Group_0__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group_0__1"
+
+
+    // $ANTLR start "rule__MessageData__Group_0__1__Impl"
+    // InternalRoom.g:5096:1: rule__MessageData__Group_0__1__Impl : ( ':' ) ;
+    public final void rule__MessageData__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:5100:1: ( ( ':' ) )
+            // InternalRoom.g:5101:1: ( ':' )
+            {
+            // InternalRoom.g:5101:1: ( ':' )
+            // InternalRoom.g:5102:1: ':'
+            {
+             before(grammarAccess.getMessageDataAccess().getColonKeyword_0_1()); 
+            match(input,46,FOLLOW_2); 
+             after(grammarAccess.getMessageDataAccess().getColonKeyword_0_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__Group_0__1__Impl"
+
+
     // $ANTLR start "rule__RefableType__Group__0"
-    // InternalRoom.g:4920:1: rule__RefableType__Group__0 : rule__RefableType__Group__0__Impl rule__RefableType__Group__1 ;
+    // InternalRoom.g:5119:1: rule__RefableType__Group__0 : rule__RefableType__Group__0__Impl rule__RefableType__Group__1 ;
     public final void rule__RefableType__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4924:1: ( rule__RefableType__Group__0__Impl rule__RefableType__Group__1 )
-            // InternalRoom.g:4925:2: rule__RefableType__Group__0__Impl rule__RefableType__Group__1
+            // InternalRoom.g:5123:1: ( rule__RefableType__Group__0__Impl rule__RefableType__Group__1 )
+            // InternalRoom.g:5124:2: rule__RefableType__Group__0__Impl rule__RefableType__Group__1
             {
             pushFollow(FOLLOW_9);
             rule__RefableType__Group__0__Impl();
@@ -15258,21 +15826,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__Group__0__Impl"
-    // InternalRoom.g:4932:1: rule__RefableType__Group__0__Impl : ( ( rule__RefableType__TypeAssignment_0 ) ) ;
+    // InternalRoom.g:5131:1: rule__RefableType__Group__0__Impl : ( ( rule__RefableType__TypeAssignment_0 ) ) ;
     public final void rule__RefableType__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4936:1: ( ( ( rule__RefableType__TypeAssignment_0 ) ) )
-            // InternalRoom.g:4937:1: ( ( rule__RefableType__TypeAssignment_0 ) )
+            // InternalRoom.g:5135:1: ( ( ( rule__RefableType__TypeAssignment_0 ) ) )
+            // InternalRoom.g:5136:1: ( ( rule__RefableType__TypeAssignment_0 ) )
             {
-            // InternalRoom.g:4937:1: ( ( rule__RefableType__TypeAssignment_0 ) )
-            // InternalRoom.g:4938:1: ( rule__RefableType__TypeAssignment_0 )
+            // InternalRoom.g:5136:1: ( ( rule__RefableType__TypeAssignment_0 ) )
+            // InternalRoom.g:5137:1: ( rule__RefableType__TypeAssignment_0 )
             {
              before(grammarAccess.getRefableTypeAccess().getTypeAssignment_0()); 
-            // InternalRoom.g:4939:1: ( rule__RefableType__TypeAssignment_0 )
-            // InternalRoom.g:4939:2: rule__RefableType__TypeAssignment_0
+            // InternalRoom.g:5138:1: ( rule__RefableType__TypeAssignment_0 )
+            // InternalRoom.g:5138:2: rule__RefableType__TypeAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefableType__TypeAssignment_0();
@@ -15305,14 +15873,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__Group__1"
-    // InternalRoom.g:4949:1: rule__RefableType__Group__1 : rule__RefableType__Group__1__Impl ;
+    // InternalRoom.g:5148:1: rule__RefableType__Group__1 : rule__RefableType__Group__1__Impl ;
     public final void rule__RefableType__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4953:1: ( rule__RefableType__Group__1__Impl )
-            // InternalRoom.g:4954:2: rule__RefableType__Group__1__Impl
+            // InternalRoom.g:5152:1: ( rule__RefableType__Group__1__Impl )
+            // InternalRoom.g:5153:2: rule__RefableType__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefableType__Group__1__Impl();
@@ -15338,29 +15906,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__Group__1__Impl"
-    // InternalRoom.g:4960:1: rule__RefableType__Group__1__Impl : ( ( rule__RefableType__RefAssignment_1 )? ) ;
+    // InternalRoom.g:5159:1: rule__RefableType__Group__1__Impl : ( ( rule__RefableType__RefAssignment_1 )? ) ;
     public final void rule__RefableType__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4964:1: ( ( ( rule__RefableType__RefAssignment_1 )? ) )
-            // InternalRoom.g:4965:1: ( ( rule__RefableType__RefAssignment_1 )? )
+            // InternalRoom.g:5163:1: ( ( ( rule__RefableType__RefAssignment_1 )? ) )
+            // InternalRoom.g:5164:1: ( ( rule__RefableType__RefAssignment_1 )? )
             {
-            // InternalRoom.g:4965:1: ( ( rule__RefableType__RefAssignment_1 )? )
-            // InternalRoom.g:4966:1: ( rule__RefableType__RefAssignment_1 )?
+            // InternalRoom.g:5164:1: ( ( rule__RefableType__RefAssignment_1 )? )
+            // InternalRoom.g:5165:1: ( rule__RefableType__RefAssignment_1 )?
             {
              before(grammarAccess.getRefableTypeAccess().getRefAssignment_1()); 
-            // InternalRoom.g:4967:1: ( rule__RefableType__RefAssignment_1 )?
-            int alt58=2;
-            int LA58_0 = input.LA(1);
+            // InternalRoom.g:5166:1: ( rule__RefableType__RefAssignment_1 )?
+            int alt60=2;
+            int LA60_0 = input.LA(1);
 
-            if ( (LA58_0==91) ) {
-                alt58=1;
+            if ( (LA60_0==91) ) {
+                alt60=1;
             }
-            switch (alt58) {
+            switch (alt60) {
                 case 1 :
-                    // InternalRoom.g:4967:2: rule__RefableType__RefAssignment_1
+                    // InternalRoom.g:5166:2: rule__RefableType__RefAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefableType__RefAssignment_1();
@@ -15396,14 +15964,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__0"
-    // InternalRoom.g:4981:1: rule__PrimitiveType__Group__0 : rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1 ;
+    // InternalRoom.g:5180:1: rule__PrimitiveType__Group__0 : rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1 ;
     public final void rule__PrimitiveType__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4985:1: ( rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1 )
-            // InternalRoom.g:4986:2: rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1
+            // InternalRoom.g:5184:1: ( rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1 )
+            // InternalRoom.g:5185:2: rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__PrimitiveType__Group__0__Impl();
@@ -15434,17 +16002,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__0__Impl"
-    // InternalRoom.g:4993:1: rule__PrimitiveType__Group__0__Impl : ( 'PrimitiveType' ) ;
+    // InternalRoom.g:5192:1: rule__PrimitiveType__Group__0__Impl : ( 'PrimitiveType' ) ;
     public final void rule__PrimitiveType__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:4997:1: ( ( 'PrimitiveType' ) )
-            // InternalRoom.g:4998:1: ( 'PrimitiveType' )
+            // InternalRoom.g:5196:1: ( ( 'PrimitiveType' ) )
+            // InternalRoom.g:5197:1: ( 'PrimitiveType' )
             {
-            // InternalRoom.g:4998:1: ( 'PrimitiveType' )
-            // InternalRoom.g:4999:1: 'PrimitiveType'
+            // InternalRoom.g:5197:1: ( 'PrimitiveType' )
+            // InternalRoom.g:5198:1: 'PrimitiveType'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getPrimitiveTypeKeyword_0()); 
             match(input,47,FOLLOW_2); 
@@ -15471,14 +16039,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__1"
-    // InternalRoom.g:5012:1: rule__PrimitiveType__Group__1 : rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2 ;
+    // InternalRoom.g:5211:1: rule__PrimitiveType__Group__1 : rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2 ;
     public final void rule__PrimitiveType__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5016:1: ( rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2 )
-            // InternalRoom.g:5017:2: rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2
+            // InternalRoom.g:5215:1: ( rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2 )
+            // InternalRoom.g:5216:2: rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__PrimitiveType__Group__1__Impl();
@@ -15509,21 +16077,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__1__Impl"
-    // InternalRoom.g:5024:1: rule__PrimitiveType__Group__1__Impl : ( ( rule__PrimitiveType__NameAssignment_1 ) ) ;
+    // InternalRoom.g:5223:1: rule__PrimitiveType__Group__1__Impl : ( ( rule__PrimitiveType__NameAssignment_1 ) ) ;
     public final void rule__PrimitiveType__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5028:1: ( ( ( rule__PrimitiveType__NameAssignment_1 ) ) )
-            // InternalRoom.g:5029:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
+            // InternalRoom.g:5227:1: ( ( ( rule__PrimitiveType__NameAssignment_1 ) ) )
+            // InternalRoom.g:5228:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5029:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
-            // InternalRoom.g:5030:1: ( rule__PrimitiveType__NameAssignment_1 )
+            // InternalRoom.g:5228:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
+            // InternalRoom.g:5229:1: ( rule__PrimitiveType__NameAssignment_1 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getNameAssignment_1()); 
-            // InternalRoom.g:5031:1: ( rule__PrimitiveType__NameAssignment_1 )
-            // InternalRoom.g:5031:2: rule__PrimitiveType__NameAssignment_1
+            // InternalRoom.g:5230:1: ( rule__PrimitiveType__NameAssignment_1 )
+            // InternalRoom.g:5230:2: rule__PrimitiveType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__NameAssignment_1();
@@ -15556,14 +16124,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__2"
-    // InternalRoom.g:5041:1: rule__PrimitiveType__Group__2 : rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3 ;
+    // InternalRoom.g:5240:1: rule__PrimitiveType__Group__2 : rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3 ;
     public final void rule__PrimitiveType__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5045:1: ( rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3 )
-            // InternalRoom.g:5046:2: rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3
+            // InternalRoom.g:5244:1: ( rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3 )
+            // InternalRoom.g:5245:2: rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3
             {
             pushFollow(FOLLOW_10);
             rule__PrimitiveType__Group__2__Impl();
@@ -15594,17 +16162,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__2__Impl"
-    // InternalRoom.g:5053:1: rule__PrimitiveType__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:5252:1: rule__PrimitiveType__Group__2__Impl : ( ':' ) ;
     public final void rule__PrimitiveType__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5057:1: ( ( ':' ) )
-            // InternalRoom.g:5058:1: ( ':' )
+            // InternalRoom.g:5256:1: ( ( ':' ) )
+            // InternalRoom.g:5257:1: ( ':' )
             {
-            // InternalRoom.g:5058:1: ( ':' )
-            // InternalRoom.g:5059:1: ':'
+            // InternalRoom.g:5257:1: ( ':' )
+            // InternalRoom.g:5258:1: ':'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -15631,14 +16199,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__3"
-    // InternalRoom.g:5072:1: rule__PrimitiveType__Group__3 : rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4 ;
+    // InternalRoom.g:5271:1: rule__PrimitiveType__Group__3 : rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4 ;
     public final void rule__PrimitiveType__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5076:1: ( rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4 )
-            // InternalRoom.g:5077:2: rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4
+            // InternalRoom.g:5275:1: ( rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4 )
+            // InternalRoom.g:5276:2: rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__PrimitiveType__Group__3__Impl();
@@ -15669,21 +16237,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__3__Impl"
-    // InternalRoom.g:5084:1: rule__PrimitiveType__Group__3__Impl : ( ( rule__PrimitiveType__TypeAssignment_3 ) ) ;
+    // InternalRoom.g:5283:1: rule__PrimitiveType__Group__3__Impl : ( ( rule__PrimitiveType__TypeAssignment_3 ) ) ;
     public final void rule__PrimitiveType__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5088:1: ( ( ( rule__PrimitiveType__TypeAssignment_3 ) ) )
-            // InternalRoom.g:5089:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
+            // InternalRoom.g:5287:1: ( ( ( rule__PrimitiveType__TypeAssignment_3 ) ) )
+            // InternalRoom.g:5288:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
             {
-            // InternalRoom.g:5089:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
-            // InternalRoom.g:5090:1: ( rule__PrimitiveType__TypeAssignment_3 )
+            // InternalRoom.g:5288:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
+            // InternalRoom.g:5289:1: ( rule__PrimitiveType__TypeAssignment_3 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTypeAssignment_3()); 
-            // InternalRoom.g:5091:1: ( rule__PrimitiveType__TypeAssignment_3 )
-            // InternalRoom.g:5091:2: rule__PrimitiveType__TypeAssignment_3
+            // InternalRoom.g:5290:1: ( rule__PrimitiveType__TypeAssignment_3 )
+            // InternalRoom.g:5290:2: rule__PrimitiveType__TypeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__TypeAssignment_3();
@@ -15716,14 +16284,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__4"
-    // InternalRoom.g:5101:1: rule__PrimitiveType__Group__4 : rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5 ;
+    // InternalRoom.g:5300:1: rule__PrimitiveType__Group__4 : rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5 ;
     public final void rule__PrimitiveType__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5105:1: ( rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5 )
-            // InternalRoom.g:5106:2: rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5
+            // InternalRoom.g:5304:1: ( rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5 )
+            // InternalRoom.g:5305:2: rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5
             {
             pushFollow(FOLLOW_12);
             rule__PrimitiveType__Group__4__Impl();
@@ -15754,17 +16322,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__4__Impl"
-    // InternalRoom.g:5113:1: rule__PrimitiveType__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:5312:1: rule__PrimitiveType__Group__4__Impl : ( '->' ) ;
     public final void rule__PrimitiveType__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5117:1: ( ( '->' ) )
-            // InternalRoom.g:5118:1: ( '->' )
+            // InternalRoom.g:5316:1: ( ( '->' ) )
+            // InternalRoom.g:5317:1: ( '->' )
             {
-            // InternalRoom.g:5118:1: ( '->' )
-            // InternalRoom.g:5119:1: '->'
+            // InternalRoom.g:5317:1: ( '->' )
+            // InternalRoom.g:5318:1: '->'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -15791,14 +16359,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__5"
-    // InternalRoom.g:5132:1: rule__PrimitiveType__Group__5 : rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6 ;
+    // InternalRoom.g:5331:1: rule__PrimitiveType__Group__5 : rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6 ;
     public final void rule__PrimitiveType__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5136:1: ( rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6 )
-            // InternalRoom.g:5137:2: rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6
+            // InternalRoom.g:5335:1: ( rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6 )
+            // InternalRoom.g:5336:2: rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6
             {
             pushFollow(FOLLOW_13);
             rule__PrimitiveType__Group__5__Impl();
@@ -15829,21 +16397,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__5__Impl"
-    // InternalRoom.g:5144:1: rule__PrimitiveType__Group__5__Impl : ( ( rule__PrimitiveType__TargetNameAssignment_5 ) ) ;
+    // InternalRoom.g:5343:1: rule__PrimitiveType__Group__5__Impl : ( ( rule__PrimitiveType__TargetNameAssignment_5 ) ) ;
     public final void rule__PrimitiveType__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5148:1: ( ( ( rule__PrimitiveType__TargetNameAssignment_5 ) ) )
-            // InternalRoom.g:5149:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
+            // InternalRoom.g:5347:1: ( ( ( rule__PrimitiveType__TargetNameAssignment_5 ) ) )
+            // InternalRoom.g:5348:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
             {
-            // InternalRoom.g:5149:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
-            // InternalRoom.g:5150:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
+            // InternalRoom.g:5348:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
+            // InternalRoom.g:5349:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTargetNameAssignment_5()); 
-            // InternalRoom.g:5151:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
-            // InternalRoom.g:5151:2: rule__PrimitiveType__TargetNameAssignment_5
+            // InternalRoom.g:5350:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
+            // InternalRoom.g:5350:2: rule__PrimitiveType__TargetNameAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__TargetNameAssignment_5();
@@ -15876,14 +16444,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__6"
-    // InternalRoom.g:5161:1: rule__PrimitiveType__Group__6 : rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7 ;
+    // InternalRoom.g:5360:1: rule__PrimitiveType__Group__6 : rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7 ;
     public final void rule__PrimitiveType__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5165:1: ( rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7 )
-            // InternalRoom.g:5166:2: rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7
+            // InternalRoom.g:5364:1: ( rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7 )
+            // InternalRoom.g:5365:2: rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7
             {
             pushFollow(FOLLOW_13);
             rule__PrimitiveType__Group__6__Impl();
@@ -15914,29 +16482,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__6__Impl"
-    // InternalRoom.g:5173:1: rule__PrimitiveType__Group__6__Impl : ( ( rule__PrimitiveType__Group_6__0 )? ) ;
+    // InternalRoom.g:5372:1: rule__PrimitiveType__Group__6__Impl : ( ( rule__PrimitiveType__Group_6__0 )? ) ;
     public final void rule__PrimitiveType__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5177:1: ( ( ( rule__PrimitiveType__Group_6__0 )? ) )
-            // InternalRoom.g:5178:1: ( ( rule__PrimitiveType__Group_6__0 )? )
+            // InternalRoom.g:5376:1: ( ( ( rule__PrimitiveType__Group_6__0 )? ) )
+            // InternalRoom.g:5377:1: ( ( rule__PrimitiveType__Group_6__0 )? )
             {
-            // InternalRoom.g:5178:1: ( ( rule__PrimitiveType__Group_6__0 )? )
-            // InternalRoom.g:5179:1: ( rule__PrimitiveType__Group_6__0 )?
+            // InternalRoom.g:5377:1: ( ( rule__PrimitiveType__Group_6__0 )? )
+            // InternalRoom.g:5378:1: ( rule__PrimitiveType__Group_6__0 )?
             {
              before(grammarAccess.getPrimitiveTypeAccess().getGroup_6()); 
-            // InternalRoom.g:5180:1: ( rule__PrimitiveType__Group_6__0 )?
-            int alt59=2;
-            int LA59_0 = input.LA(1);
+            // InternalRoom.g:5379:1: ( rule__PrimitiveType__Group_6__0 )?
+            int alt61=2;
+            int LA61_0 = input.LA(1);
 
-            if ( (LA59_0==50) ) {
-                alt59=1;
+            if ( (LA61_0==50) ) {
+                alt61=1;
             }
-            switch (alt59) {
+            switch (alt61) {
                 case 1 :
-                    // InternalRoom.g:5180:2: rule__PrimitiveType__Group_6__0
+                    // InternalRoom.g:5379:2: rule__PrimitiveType__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PrimitiveType__Group_6__0();
@@ -15972,14 +16540,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__7"
-    // InternalRoom.g:5190:1: rule__PrimitiveType__Group__7 : rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8 ;
+    // InternalRoom.g:5389:1: rule__PrimitiveType__Group__7 : rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8 ;
     public final void rule__PrimitiveType__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5194:1: ( rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8 )
-            // InternalRoom.g:5195:2: rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8
+            // InternalRoom.g:5393:1: ( rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8 )
+            // InternalRoom.g:5394:2: rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8
             {
             pushFollow(FOLLOW_12);
             rule__PrimitiveType__Group__7__Impl();
@@ -16010,17 +16578,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__7__Impl"
-    // InternalRoom.g:5202:1: rule__PrimitiveType__Group__7__Impl : ( 'default' ) ;
+    // InternalRoom.g:5401:1: rule__PrimitiveType__Group__7__Impl : ( 'default' ) ;
     public final void rule__PrimitiveType__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5206:1: ( ( 'default' ) )
-            // InternalRoom.g:5207:1: ( 'default' )
+            // InternalRoom.g:5405:1: ( ( 'default' ) )
+            // InternalRoom.g:5406:1: ( 'default' )
             {
-            // InternalRoom.g:5207:1: ( 'default' )
-            // InternalRoom.g:5208:1: 'default'
+            // InternalRoom.g:5406:1: ( 'default' )
+            // InternalRoom.g:5407:1: 'default'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDefaultKeyword_7()); 
             match(input,49,FOLLOW_2); 
@@ -16047,14 +16615,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__8"
-    // InternalRoom.g:5221:1: rule__PrimitiveType__Group__8 : rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9 ;
+    // InternalRoom.g:5420:1: rule__PrimitiveType__Group__8 : rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9 ;
     public final void rule__PrimitiveType__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5225:1: ( rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9 )
-            // InternalRoom.g:5226:2: rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9
+            // InternalRoom.g:5424:1: ( rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9 )
+            // InternalRoom.g:5425:2: rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9
             {
             pushFollow(FOLLOW_14);
             rule__PrimitiveType__Group__8__Impl();
@@ -16085,21 +16653,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__8__Impl"
-    // InternalRoom.g:5233:1: rule__PrimitiveType__Group__8__Impl : ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) ) ;
+    // InternalRoom.g:5432:1: rule__PrimitiveType__Group__8__Impl : ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) ) ;
     public final void rule__PrimitiveType__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5237:1: ( ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) ) )
-            // InternalRoom.g:5238:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
+            // InternalRoom.g:5436:1: ( ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) ) )
+            // InternalRoom.g:5437:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
             {
-            // InternalRoom.g:5238:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
-            // InternalRoom.g:5239:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
+            // InternalRoom.g:5437:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
+            // InternalRoom.g:5438:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralAssignment_8()); 
-            // InternalRoom.g:5240:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
-            // InternalRoom.g:5240:2: rule__PrimitiveType__DefaultValueLiteralAssignment_8
+            // InternalRoom.g:5439:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
+            // InternalRoom.g:5439:2: rule__PrimitiveType__DefaultValueLiteralAssignment_8
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__DefaultValueLiteralAssignment_8();
@@ -16132,14 +16700,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__9"
-    // InternalRoom.g:5250:1: rule__PrimitiveType__Group__9 : rule__PrimitiveType__Group__9__Impl ;
+    // InternalRoom.g:5449:1: rule__PrimitiveType__Group__9 : rule__PrimitiveType__Group__9__Impl ;
     public final void rule__PrimitiveType__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5254:1: ( rule__PrimitiveType__Group__9__Impl )
-            // InternalRoom.g:5255:2: rule__PrimitiveType__Group__9__Impl
+            // InternalRoom.g:5453:1: ( rule__PrimitiveType__Group__9__Impl )
+            // InternalRoom.g:5454:2: rule__PrimitiveType__Group__9__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__Group__9__Impl();
@@ -16165,29 +16733,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__9__Impl"
-    // InternalRoom.g:5261:1: rule__PrimitiveType__Group__9__Impl : ( ( rule__PrimitiveType__DocuAssignment_9 )? ) ;
+    // InternalRoom.g:5460:1: rule__PrimitiveType__Group__9__Impl : ( ( rule__PrimitiveType__DocuAssignment_9 )? ) ;
     public final void rule__PrimitiveType__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5265:1: ( ( ( rule__PrimitiveType__DocuAssignment_9 )? ) )
-            // InternalRoom.g:5266:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
+            // InternalRoom.g:5464:1: ( ( ( rule__PrimitiveType__DocuAssignment_9 )? ) )
+            // InternalRoom.g:5465:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
             {
-            // InternalRoom.g:5266:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
-            // InternalRoom.g:5267:1: ( rule__PrimitiveType__DocuAssignment_9 )?
+            // InternalRoom.g:5465:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
+            // InternalRoom.g:5466:1: ( rule__PrimitiveType__DocuAssignment_9 )?
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDocuAssignment_9()); 
-            // InternalRoom.g:5268:1: ( rule__PrimitiveType__DocuAssignment_9 )?
-            int alt60=2;
-            int LA60_0 = input.LA(1);
+            // InternalRoom.g:5467:1: ( rule__PrimitiveType__DocuAssignment_9 )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
 
-            if ( (LA60_0==62) ) {
-                alt60=1;
+            if ( (LA62_0==62) ) {
+                alt62=1;
             }
-            switch (alt60) {
+            switch (alt62) {
                 case 1 :
-                    // InternalRoom.g:5268:2: rule__PrimitiveType__DocuAssignment_9
+                    // InternalRoom.g:5467:2: rule__PrimitiveType__DocuAssignment_9
                     {
                     pushFollow(FOLLOW_2);
                     rule__PrimitiveType__DocuAssignment_9();
@@ -16223,14 +16791,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__0"
-    // InternalRoom.g:5298:1: rule__PrimitiveType__Group_6__0 : rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1 ;
+    // InternalRoom.g:5497:1: rule__PrimitiveType__Group_6__0 : rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1 ;
     public final void rule__PrimitiveType__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5302:1: ( rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1 )
-            // InternalRoom.g:5303:2: rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1
+            // InternalRoom.g:5501:1: ( rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1 )
+            // InternalRoom.g:5502:2: rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1
             {
             pushFollow(FOLLOW_3);
             rule__PrimitiveType__Group_6__0__Impl();
@@ -16261,17 +16829,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__0__Impl"
-    // InternalRoom.g:5310:1: rule__PrimitiveType__Group_6__0__Impl : ( '(' ) ;
+    // InternalRoom.g:5509:1: rule__PrimitiveType__Group_6__0__Impl : ( '(' ) ;
     public final void rule__PrimitiveType__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5314:1: ( ( '(' ) )
-            // InternalRoom.g:5315:1: ( '(' )
+            // InternalRoom.g:5513:1: ( ( '(' ) )
+            // InternalRoom.g:5514:1: ( '(' )
             {
-            // InternalRoom.g:5315:1: ( '(' )
-            // InternalRoom.g:5316:1: '('
+            // InternalRoom.g:5514:1: ( '(' )
+            // InternalRoom.g:5515:1: '('
             {
              before(grammarAccess.getPrimitiveTypeAccess().getLeftParenthesisKeyword_6_0()); 
             match(input,50,FOLLOW_2); 
@@ -16298,14 +16866,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__1"
-    // InternalRoom.g:5329:1: rule__PrimitiveType__Group_6__1 : rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2 ;
+    // InternalRoom.g:5528:1: rule__PrimitiveType__Group_6__1 : rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2 ;
     public final void rule__PrimitiveType__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5333:1: ( rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2 )
-            // InternalRoom.g:5334:2: rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2
+            // InternalRoom.g:5532:1: ( rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2 )
+            // InternalRoom.g:5533:2: rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2
             {
             pushFollow(FOLLOW_15);
             rule__PrimitiveType__Group_6__1__Impl();
@@ -16336,21 +16904,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__1__Impl"
-    // InternalRoom.g:5341:1: rule__PrimitiveType__Group_6__1__Impl : ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) ) ;
+    // InternalRoom.g:5540:1: rule__PrimitiveType__Group_6__1__Impl : ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) ) ;
     public final void rule__PrimitiveType__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5345:1: ( ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) ) )
-            // InternalRoom.g:5346:1: ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) )
+            // InternalRoom.g:5544:1: ( ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) ) )
+            // InternalRoom.g:5545:1: ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) )
             {
-            // InternalRoom.g:5346:1: ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) )
-            // InternalRoom.g:5347:1: ( rule__PrimitiveType__CastNameAssignment_6_1 )
+            // InternalRoom.g:5545:1: ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) )
+            // InternalRoom.g:5546:1: ( rule__PrimitiveType__CastNameAssignment_6_1 )
             {
              before(grammarAccess.getPrimitiveTypeAccess().getCastNameAssignment_6_1()); 
-            // InternalRoom.g:5348:1: ( rule__PrimitiveType__CastNameAssignment_6_1 )
-            // InternalRoom.g:5348:2: rule__PrimitiveType__CastNameAssignment_6_1
+            // InternalRoom.g:5547:1: ( rule__PrimitiveType__CastNameAssignment_6_1 )
+            // InternalRoom.g:5547:2: rule__PrimitiveType__CastNameAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__CastNameAssignment_6_1();
@@ -16383,14 +16951,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__2"
-    // InternalRoom.g:5358:1: rule__PrimitiveType__Group_6__2 : rule__PrimitiveType__Group_6__2__Impl ;
+    // InternalRoom.g:5557:1: rule__PrimitiveType__Group_6__2 : rule__PrimitiveType__Group_6__2__Impl ;
     public final void rule__PrimitiveType__Group_6__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5362:1: ( rule__PrimitiveType__Group_6__2__Impl )
-            // InternalRoom.g:5363:2: rule__PrimitiveType__Group_6__2__Impl
+            // InternalRoom.g:5561:1: ( rule__PrimitiveType__Group_6__2__Impl )
+            // InternalRoom.g:5562:2: rule__PrimitiveType__Group_6__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__Group_6__2__Impl();
@@ -16416,17 +16984,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group_6__2__Impl"
-    // InternalRoom.g:5369:1: rule__PrimitiveType__Group_6__2__Impl : ( ')' ) ;
+    // InternalRoom.g:5568:1: rule__PrimitiveType__Group_6__2__Impl : ( ')' ) ;
     public final void rule__PrimitiveType__Group_6__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5373:1: ( ( ')' ) )
-            // InternalRoom.g:5374:1: ( ')' )
+            // InternalRoom.g:5572:1: ( ( ')' ) )
+            // InternalRoom.g:5573:1: ( ')' )
             {
-            // InternalRoom.g:5374:1: ( ')' )
-            // InternalRoom.g:5375:1: ')'
+            // InternalRoom.g:5573:1: ( ')' )
+            // InternalRoom.g:5574:1: ')'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getRightParenthesisKeyword_6_2()); 
             match(input,51,FOLLOW_2); 
@@ -16453,14 +17021,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__0"
-    // InternalRoom.g:5394:1: rule__EnumerationType__Group__0 : rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1 ;
+    // InternalRoom.g:5593:1: rule__EnumerationType__Group__0 : rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1 ;
     public final void rule__EnumerationType__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5398:1: ( rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1 )
-            // InternalRoom.g:5399:2: rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1
+            // InternalRoom.g:5597:1: ( rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1 )
+            // InternalRoom.g:5598:2: rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__EnumerationType__Group__0__Impl();
@@ -16491,17 +17059,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__0__Impl"
-    // InternalRoom.g:5406:1: rule__EnumerationType__Group__0__Impl : ( 'Enumeration' ) ;
+    // InternalRoom.g:5605:1: rule__EnumerationType__Group__0__Impl : ( 'Enumeration' ) ;
     public final void rule__EnumerationType__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5410:1: ( ( 'Enumeration' ) )
-            // InternalRoom.g:5411:1: ( 'Enumeration' )
+            // InternalRoom.g:5609:1: ( ( 'Enumeration' ) )
+            // InternalRoom.g:5610:1: ( 'Enumeration' )
             {
-            // InternalRoom.g:5411:1: ( 'Enumeration' )
-            // InternalRoom.g:5412:1: 'Enumeration'
+            // InternalRoom.g:5610:1: ( 'Enumeration' )
+            // InternalRoom.g:5611:1: 'Enumeration'
             {
              before(grammarAccess.getEnumerationTypeAccess().getEnumerationKeyword_0()); 
             match(input,52,FOLLOW_2); 
@@ -16528,14 +17096,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__1"
-    // InternalRoom.g:5425:1: rule__EnumerationType__Group__1 : rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2 ;
+    // InternalRoom.g:5624:1: rule__EnumerationType__Group__1 : rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2 ;
     public final void rule__EnumerationType__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5429:1: ( rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2 )
-            // InternalRoom.g:5430:2: rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2
+            // InternalRoom.g:5628:1: ( rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2 )
+            // InternalRoom.g:5629:2: rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__1__Impl();
@@ -16566,21 +17134,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__1__Impl"
-    // InternalRoom.g:5437:1: rule__EnumerationType__Group__1__Impl : ( ( rule__EnumerationType__NameAssignment_1 ) ) ;
+    // InternalRoom.g:5636:1: rule__EnumerationType__Group__1__Impl : ( ( rule__EnumerationType__NameAssignment_1 ) ) ;
     public final void rule__EnumerationType__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5441:1: ( ( ( rule__EnumerationType__NameAssignment_1 ) ) )
-            // InternalRoom.g:5442:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
+            // InternalRoom.g:5640:1: ( ( ( rule__EnumerationType__NameAssignment_1 ) ) )
+            // InternalRoom.g:5641:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5442:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
-            // InternalRoom.g:5443:1: ( rule__EnumerationType__NameAssignment_1 )
+            // InternalRoom.g:5641:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
+            // InternalRoom.g:5642:1: ( rule__EnumerationType__NameAssignment_1 )
             {
              before(grammarAccess.getEnumerationTypeAccess().getNameAssignment_1()); 
-            // InternalRoom.g:5444:1: ( rule__EnumerationType__NameAssignment_1 )
-            // InternalRoom.g:5444:2: rule__EnumerationType__NameAssignment_1
+            // InternalRoom.g:5643:1: ( rule__EnumerationType__NameAssignment_1 )
+            // InternalRoom.g:5643:2: rule__EnumerationType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__NameAssignment_1();
@@ -16613,14 +17181,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__2"
-    // InternalRoom.g:5454:1: rule__EnumerationType__Group__2 : rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3 ;
+    // InternalRoom.g:5653:1: rule__EnumerationType__Group__2 : rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3 ;
     public final void rule__EnumerationType__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5458:1: ( rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3 )
-            // InternalRoom.g:5459:2: rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3
+            // InternalRoom.g:5657:1: ( rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3 )
+            // InternalRoom.g:5658:2: rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__2__Impl();
@@ -16651,29 +17219,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__2__Impl"
-    // InternalRoom.g:5466:1: rule__EnumerationType__Group__2__Impl : ( ( rule__EnumerationType__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:5665:1: rule__EnumerationType__Group__2__Impl : ( ( rule__EnumerationType__DocuAssignment_2 )? ) ;
     public final void rule__EnumerationType__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5470:1: ( ( ( rule__EnumerationType__DocuAssignment_2 )? ) )
-            // InternalRoom.g:5471:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
+            // InternalRoom.g:5669:1: ( ( ( rule__EnumerationType__DocuAssignment_2 )? ) )
+            // InternalRoom.g:5670:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:5471:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
-            // InternalRoom.g:5472:1: ( rule__EnumerationType__DocuAssignment_2 )?
+            // InternalRoom.g:5670:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
+            // InternalRoom.g:5671:1: ( rule__EnumerationType__DocuAssignment_2 )?
             {
              before(grammarAccess.getEnumerationTypeAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:5473:1: ( rule__EnumerationType__DocuAssignment_2 )?
-            int alt61=2;
-            int LA61_0 = input.LA(1);
+            // InternalRoom.g:5672:1: ( rule__EnumerationType__DocuAssignment_2 )?
+            int alt63=2;
+            int LA63_0 = input.LA(1);
 
-            if ( (LA61_0==62) ) {
-                alt61=1;
+            if ( (LA63_0==62) ) {
+                alt63=1;
             }
-            switch (alt61) {
+            switch (alt63) {
                 case 1 :
-                    // InternalRoom.g:5473:2: rule__EnumerationType__DocuAssignment_2
+                    // InternalRoom.g:5672:2: rule__EnumerationType__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__DocuAssignment_2();
@@ -16709,14 +17277,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__3"
-    // InternalRoom.g:5483:1: rule__EnumerationType__Group__3 : rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4 ;
+    // InternalRoom.g:5682:1: rule__EnumerationType__Group__3 : rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4 ;
     public final void rule__EnumerationType__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5487:1: ( rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4 )
-            // InternalRoom.g:5488:2: rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4
+            // InternalRoom.g:5686:1: ( rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4 )
+            // InternalRoom.g:5687:2: rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__3__Impl();
@@ -16747,29 +17315,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__3__Impl"
-    // InternalRoom.g:5495:1: rule__EnumerationType__Group__3__Impl : ( ( rule__EnumerationType__Group_3__0 )? ) ;
+    // InternalRoom.g:5694:1: rule__EnumerationType__Group__3__Impl : ( ( rule__EnumerationType__Group_3__0 )? ) ;
     public final void rule__EnumerationType__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5499:1: ( ( ( rule__EnumerationType__Group_3__0 )? ) )
-            // InternalRoom.g:5500:1: ( ( rule__EnumerationType__Group_3__0 )? )
+            // InternalRoom.g:5698:1: ( ( ( rule__EnumerationType__Group_3__0 )? ) )
+            // InternalRoom.g:5699:1: ( ( rule__EnumerationType__Group_3__0 )? )
             {
-            // InternalRoom.g:5500:1: ( ( rule__EnumerationType__Group_3__0 )? )
-            // InternalRoom.g:5501:1: ( rule__EnumerationType__Group_3__0 )?
+            // InternalRoom.g:5699:1: ( ( rule__EnumerationType__Group_3__0 )? )
+            // InternalRoom.g:5700:1: ( rule__EnumerationType__Group_3__0 )?
             {
              before(grammarAccess.getEnumerationTypeAccess().getGroup_3()); 
-            // InternalRoom.g:5502:1: ( rule__EnumerationType__Group_3__0 )?
-            int alt62=2;
-            int LA62_0 = input.LA(1);
+            // InternalRoom.g:5701:1: ( rule__EnumerationType__Group_3__0 )?
+            int alt64=2;
+            int LA64_0 = input.LA(1);
 
-            if ( (LA62_0==53) ) {
-                alt62=1;
+            if ( (LA64_0==53) ) {
+                alt64=1;
             }
-            switch (alt62) {
+            switch (alt64) {
                 case 1 :
-                    // InternalRoom.g:5502:2: rule__EnumerationType__Group_3__0
+                    // InternalRoom.g:5701:2: rule__EnumerationType__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__Group_3__0();
@@ -16805,14 +17373,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__4"
-    // InternalRoom.g:5512:1: rule__EnumerationType__Group__4 : rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5 ;
+    // InternalRoom.g:5711:1: rule__EnumerationType__Group__4 : rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5 ;
     public final void rule__EnumerationType__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5516:1: ( rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5 )
-            // InternalRoom.g:5517:2: rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5
+            // InternalRoom.g:5715:1: ( rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5 )
+            // InternalRoom.g:5716:2: rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5
             {
             pushFollow(FOLLOW_17);
             rule__EnumerationType__Group__4__Impl();
@@ -16843,17 +17411,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__4__Impl"
-    // InternalRoom.g:5524:1: rule__EnumerationType__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:5723:1: rule__EnumerationType__Group__4__Impl : ( '{' ) ;
     public final void rule__EnumerationType__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5528:1: ( ( '{' ) )
-            // InternalRoom.g:5529:1: ( '{' )
+            // InternalRoom.g:5727:1: ( ( '{' ) )
+            // InternalRoom.g:5728:1: ( '{' )
             {
-            // InternalRoom.g:5529:1: ( '{' )
-            // InternalRoom.g:5530:1: '{'
+            // InternalRoom.g:5728:1: ( '{' )
+            // InternalRoom.g:5729:1: '{'
             {
              before(grammarAccess.getEnumerationTypeAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -16880,14 +17448,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__5"
-    // InternalRoom.g:5543:1: rule__EnumerationType__Group__5 : rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6 ;
+    // InternalRoom.g:5742:1: rule__EnumerationType__Group__5 : rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6 ;
     public final void rule__EnumerationType__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5547:1: ( rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6 )
-            // InternalRoom.g:5548:2: rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6
+            // InternalRoom.g:5746:1: ( rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6 )
+            // InternalRoom.g:5747:2: rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6
             {
             pushFollow(FOLLOW_17);
             rule__EnumerationType__Group__5__Impl();
@@ -16918,29 +17486,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__5__Impl"
-    // InternalRoom.g:5555:1: rule__EnumerationType__Group__5__Impl : ( ( rule__EnumerationType__Group_5__0 )? ) ;
+    // InternalRoom.g:5754:1: rule__EnumerationType__Group__5__Impl : ( ( rule__EnumerationType__Group_5__0 )? ) ;
     public final void rule__EnumerationType__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5559:1: ( ( ( rule__EnumerationType__Group_5__0 )? ) )
-            // InternalRoom.g:5560:1: ( ( rule__EnumerationType__Group_5__0 )? )
+            // InternalRoom.g:5758:1: ( ( ( rule__EnumerationType__Group_5__0 )? ) )
+            // InternalRoom.g:5759:1: ( ( rule__EnumerationType__Group_5__0 )? )
             {
-            // InternalRoom.g:5560:1: ( ( rule__EnumerationType__Group_5__0 )? )
-            // InternalRoom.g:5561:1: ( rule__EnumerationType__Group_5__0 )?
+            // InternalRoom.g:5759:1: ( ( rule__EnumerationType__Group_5__0 )? )
+            // InternalRoom.g:5760:1: ( rule__EnumerationType__Group_5__0 )?
             {
              before(grammarAccess.getEnumerationTypeAccess().getGroup_5()); 
-            // InternalRoom.g:5562:1: ( rule__EnumerationType__Group_5__0 )?
-            int alt63=2;
-            int LA63_0 = input.LA(1);
+            // InternalRoom.g:5761:1: ( rule__EnumerationType__Group_5__0 )?
+            int alt65=2;
+            int LA65_0 = input.LA(1);
 
-            if ( (LA63_0==RULE_ID) ) {
-                alt63=1;
+            if ( (LA65_0==RULE_ID) ) {
+                alt65=1;
             }
-            switch (alt63) {
+            switch (alt65) {
                 case 1 :
-                    // InternalRoom.g:5562:2: rule__EnumerationType__Group_5__0
+                    // InternalRoom.g:5761:2: rule__EnumerationType__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__Group_5__0();
@@ -16976,14 +17544,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__6"
-    // InternalRoom.g:5572:1: rule__EnumerationType__Group__6 : rule__EnumerationType__Group__6__Impl ;
+    // InternalRoom.g:5771:1: rule__EnumerationType__Group__6 : rule__EnumerationType__Group__6__Impl ;
     public final void rule__EnumerationType__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5576:1: ( rule__EnumerationType__Group__6__Impl )
-            // InternalRoom.g:5577:2: rule__EnumerationType__Group__6__Impl
+            // InternalRoom.g:5775:1: ( rule__EnumerationType__Group__6__Impl )
+            // InternalRoom.g:5776:2: rule__EnumerationType__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group__6__Impl();
@@ -17009,17 +17577,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__6__Impl"
-    // InternalRoom.g:5583:1: rule__EnumerationType__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:5782:1: rule__EnumerationType__Group__6__Impl : ( '}' ) ;
     public final void rule__EnumerationType__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5587:1: ( ( '}' ) )
-            // InternalRoom.g:5588:1: ( '}' )
+            // InternalRoom.g:5786:1: ( ( '}' ) )
+            // InternalRoom.g:5787:1: ( '}' )
             {
-            // InternalRoom.g:5588:1: ( '}' )
-            // InternalRoom.g:5589:1: '}'
+            // InternalRoom.g:5787:1: ( '}' )
+            // InternalRoom.g:5788:1: '}'
             {
              before(grammarAccess.getEnumerationTypeAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -17046,14 +17614,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_3__0"
-    // InternalRoom.g:5616:1: rule__EnumerationType__Group_3__0 : rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1 ;
+    // InternalRoom.g:5815:1: rule__EnumerationType__Group_3__0 : rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1 ;
     public final void rule__EnumerationType__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5620:1: ( rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1 )
-            // InternalRoom.g:5621:2: rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1
+            // InternalRoom.g:5819:1: ( rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1 )
+            // InternalRoom.g:5820:2: rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1
             {
             pushFollow(FOLLOW_3);
             rule__EnumerationType__Group_3__0__Impl();
@@ -17084,17 +17652,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_3__0__Impl"
-    // InternalRoom.g:5628:1: rule__EnumerationType__Group_3__0__Impl : ( 'of' ) ;
+    // InternalRoom.g:5827:1: rule__EnumerationType__Group_3__0__Impl : ( 'of' ) ;
     public final void rule__EnumerationType__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5632:1: ( ( 'of' ) )
-            // InternalRoom.g:5633:1: ( 'of' )
+            // InternalRoom.g:5831:1: ( ( 'of' ) )
+            // InternalRoom.g:5832:1: ( 'of' )
             {
-            // InternalRoom.g:5633:1: ( 'of' )
-            // InternalRoom.g:5634:1: 'of'
+            // InternalRoom.g:5832:1: ( 'of' )
+            // InternalRoom.g:5833:1: 'of'
             {
              before(grammarAccess.getEnumerationTypeAccess().getOfKeyword_3_0()); 
             match(input,53,FOLLOW_2); 
@@ -17121,14 +17689,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_3__1"
-    // InternalRoom.g:5647:1: rule__EnumerationType__Group_3__1 : rule__EnumerationType__Group_3__1__Impl ;
+    // InternalRoom.g:5846:1: rule__EnumerationType__Group_3__1 : rule__EnumerationType__Group_3__1__Impl ;
     public final void rule__EnumerationType__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5651:1: ( rule__EnumerationType__Group_3__1__Impl )
-            // InternalRoom.g:5652:2: rule__EnumerationType__Group_3__1__Impl
+            // InternalRoom.g:5850:1: ( rule__EnumerationType__Group_3__1__Impl )
+            // InternalRoom.g:5851:2: rule__EnumerationType__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_3__1__Impl();
@@ -17154,21 +17722,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_3__1__Impl"
-    // InternalRoom.g:5658:1: rule__EnumerationType__Group_3__1__Impl : ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) ) ;
+    // InternalRoom.g:5857:1: rule__EnumerationType__Group_3__1__Impl : ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) ) ;
     public final void rule__EnumerationType__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5662:1: ( ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) ) )
-            // InternalRoom.g:5663:1: ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) )
+            // InternalRoom.g:5861:1: ( ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) ) )
+            // InternalRoom.g:5862:1: ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) )
             {
-            // InternalRoom.g:5663:1: ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) )
-            // InternalRoom.g:5664:1: ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 )
+            // InternalRoom.g:5862:1: ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) )
+            // InternalRoom.g:5863:1: ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 )
             {
              before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypeAssignment_3_1()); 
-            // InternalRoom.g:5665:1: ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 )
-            // InternalRoom.g:5665:2: rule__EnumerationType__PrimitiveTypeAssignment_3_1
+            // InternalRoom.g:5864:1: ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 )
+            // InternalRoom.g:5864:2: rule__EnumerationType__PrimitiveTypeAssignment_3_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__PrimitiveTypeAssignment_3_1();
@@ -17201,14 +17769,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5__0"
-    // InternalRoom.g:5679:1: rule__EnumerationType__Group_5__0 : rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1 ;
+    // InternalRoom.g:5878:1: rule__EnumerationType__Group_5__0 : rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1 ;
     public final void rule__EnumerationType__Group_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5683:1: ( rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1 )
-            // InternalRoom.g:5684:2: rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1
+            // InternalRoom.g:5882:1: ( rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1 )
+            // InternalRoom.g:5883:2: rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1
             {
             pushFollow(FOLLOW_18);
             rule__EnumerationType__Group_5__0__Impl();
@@ -17239,21 +17807,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5__0__Impl"
-    // InternalRoom.g:5691:1: rule__EnumerationType__Group_5__0__Impl : ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) ) ;
+    // InternalRoom.g:5890:1: rule__EnumerationType__Group_5__0__Impl : ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) ) ;
     public final void rule__EnumerationType__Group_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5695:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) ) )
-            // InternalRoom.g:5696:1: ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) )
+            // InternalRoom.g:5894:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) ) )
+            // InternalRoom.g:5895:1: ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) )
             {
-            // InternalRoom.g:5696:1: ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) )
-            // InternalRoom.g:5697:1: ( rule__EnumerationType__LiteralsAssignment_5_0 )
+            // InternalRoom.g:5895:1: ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) )
+            // InternalRoom.g:5896:1: ( rule__EnumerationType__LiteralsAssignment_5_0 )
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_0()); 
-            // InternalRoom.g:5698:1: ( rule__EnumerationType__LiteralsAssignment_5_0 )
-            // InternalRoom.g:5698:2: rule__EnumerationType__LiteralsAssignment_5_0
+            // InternalRoom.g:5897:1: ( rule__EnumerationType__LiteralsAssignment_5_0 )
+            // InternalRoom.g:5897:2: rule__EnumerationType__LiteralsAssignment_5_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__LiteralsAssignment_5_0();
@@ -17286,14 +17854,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5__1"
-    // InternalRoom.g:5708:1: rule__EnumerationType__Group_5__1 : rule__EnumerationType__Group_5__1__Impl ;
+    // InternalRoom.g:5907:1: rule__EnumerationType__Group_5__1 : rule__EnumerationType__Group_5__1__Impl ;
     public final void rule__EnumerationType__Group_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5712:1: ( rule__EnumerationType__Group_5__1__Impl )
-            // InternalRoom.g:5713:2: rule__EnumerationType__Group_5__1__Impl
+            // InternalRoom.g:5911:1: ( rule__EnumerationType__Group_5__1__Impl )
+            // InternalRoom.g:5912:2: rule__EnumerationType__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_5__1__Impl();
@@ -17319,33 +17887,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5__1__Impl"
-    // InternalRoom.g:5719:1: rule__EnumerationType__Group_5__1__Impl : ( ( rule__EnumerationType__Group_5_1__0 )* ) ;
+    // InternalRoom.g:5918:1: rule__EnumerationType__Group_5__1__Impl : ( ( rule__EnumerationType__Group_5_1__0 )* ) ;
     public final void rule__EnumerationType__Group_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5723:1: ( ( ( rule__EnumerationType__Group_5_1__0 )* ) )
-            // InternalRoom.g:5724:1: ( ( rule__EnumerationType__Group_5_1__0 )* )
+            // InternalRoom.g:5922:1: ( ( ( rule__EnumerationType__Group_5_1__0 )* ) )
+            // InternalRoom.g:5923:1: ( ( rule__EnumerationType__Group_5_1__0 )* )
             {
-            // InternalRoom.g:5724:1: ( ( rule__EnumerationType__Group_5_1__0 )* )
-            // InternalRoom.g:5725:1: ( rule__EnumerationType__Group_5_1__0 )*
+            // InternalRoom.g:5923:1: ( ( rule__EnumerationType__Group_5_1__0 )* )
+            // InternalRoom.g:5924:1: ( rule__EnumerationType__Group_5_1__0 )*
             {
              before(grammarAccess.getEnumerationTypeAccess().getGroup_5_1()); 
-            // InternalRoom.g:5726:1: ( rule__EnumerationType__Group_5_1__0 )*
-            loop64:
+            // InternalRoom.g:5925:1: ( rule__EnumerationType__Group_5_1__0 )*
+            loop66:
             do {
-                int alt64=2;
-                int LA64_0 = input.LA(1);
+                int alt66=2;
+                int LA66_0 = input.LA(1);
 
-                if ( (LA64_0==54) ) {
-                    alt64=1;
+                if ( (LA66_0==54) ) {
+                    alt66=1;
                 }
 
 
-                switch (alt64) {
+                switch (alt66) {
             	case 1 :
-            	    // InternalRoom.g:5726:2: rule__EnumerationType__Group_5_1__0
+            	    // InternalRoom.g:5925:2: rule__EnumerationType__Group_5_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__EnumerationType__Group_5_1__0();
@@ -17357,7 +17925,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop64;
+            	    break loop66;
                 }
             } while (true);
 
@@ -17384,14 +17952,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5_1__0"
-    // InternalRoom.g:5740:1: rule__EnumerationType__Group_5_1__0 : rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1 ;
+    // InternalRoom.g:5939:1: rule__EnumerationType__Group_5_1__0 : rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1 ;
     public final void rule__EnumerationType__Group_5_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5744:1: ( rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1 )
-            // InternalRoom.g:5745:2: rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1
+            // InternalRoom.g:5943:1: ( rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1 )
+            // InternalRoom.g:5944:2: rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1
             {
             pushFollow(FOLLOW_3);
             rule__EnumerationType__Group_5_1__0__Impl();
@@ -17422,17 +17990,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5_1__0__Impl"
-    // InternalRoom.g:5752:1: rule__EnumerationType__Group_5_1__0__Impl : ( ',' ) ;
+    // InternalRoom.g:5951:1: rule__EnumerationType__Group_5_1__0__Impl : ( ',' ) ;
     public final void rule__EnumerationType__Group_5_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5756:1: ( ( ',' ) )
-            // InternalRoom.g:5757:1: ( ',' )
+            // InternalRoom.g:5955:1: ( ( ',' ) )
+            // InternalRoom.g:5956:1: ( ',' )
             {
-            // InternalRoom.g:5757:1: ( ',' )
-            // InternalRoom.g:5758:1: ','
+            // InternalRoom.g:5956:1: ( ',' )
+            // InternalRoom.g:5957:1: ','
             {
              before(grammarAccess.getEnumerationTypeAccess().getCommaKeyword_5_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -17459,14 +18027,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5_1__1"
-    // InternalRoom.g:5771:1: rule__EnumerationType__Group_5_1__1 : rule__EnumerationType__Group_5_1__1__Impl ;
+    // InternalRoom.g:5970:1: rule__EnumerationType__Group_5_1__1 : rule__EnumerationType__Group_5_1__1__Impl ;
     public final void rule__EnumerationType__Group_5_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5775:1: ( rule__EnumerationType__Group_5_1__1__Impl )
-            // InternalRoom.g:5776:2: rule__EnumerationType__Group_5_1__1__Impl
+            // InternalRoom.g:5974:1: ( rule__EnumerationType__Group_5_1__1__Impl )
+            // InternalRoom.g:5975:2: rule__EnumerationType__Group_5_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_5_1__1__Impl();
@@ -17492,21 +18060,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group_5_1__1__Impl"
-    // InternalRoom.g:5782:1: rule__EnumerationType__Group_5_1__1__Impl : ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) ) ;
+    // InternalRoom.g:5981:1: rule__EnumerationType__Group_5_1__1__Impl : ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) ) ;
     public final void rule__EnumerationType__Group_5_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5786:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) ) )
-            // InternalRoom.g:5787:1: ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) )
+            // InternalRoom.g:5985:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) ) )
+            // InternalRoom.g:5986:1: ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) )
             {
-            // InternalRoom.g:5787:1: ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) )
-            // InternalRoom.g:5788:1: ( rule__EnumerationType__LiteralsAssignment_5_1_1 )
+            // InternalRoom.g:5986:1: ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) )
+            // InternalRoom.g:5987:1: ( rule__EnumerationType__LiteralsAssignment_5_1_1 )
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_1_1()); 
-            // InternalRoom.g:5789:1: ( rule__EnumerationType__LiteralsAssignment_5_1_1 )
-            // InternalRoom.g:5789:2: rule__EnumerationType__LiteralsAssignment_5_1_1
+            // InternalRoom.g:5988:1: ( rule__EnumerationType__LiteralsAssignment_5_1_1 )
+            // InternalRoom.g:5988:2: rule__EnumerationType__LiteralsAssignment_5_1_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__LiteralsAssignment_5_1_1();
@@ -17539,14 +18107,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group__0"
-    // InternalRoom.g:5803:1: rule__EnumLiteral__Group__0 : rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1 ;
+    // InternalRoom.g:6002:1: rule__EnumLiteral__Group__0 : rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1 ;
     public final void rule__EnumLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5807:1: ( rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1 )
-            // InternalRoom.g:5808:2: rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1
+            // InternalRoom.g:6006:1: ( rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1 )
+            // InternalRoom.g:6007:2: rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1
             {
             pushFollow(FOLLOW_20);
             rule__EnumLiteral__Group__0__Impl();
@@ -17577,21 +18145,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group__0__Impl"
-    // InternalRoom.g:5815:1: rule__EnumLiteral__Group__0__Impl : ( ( rule__EnumLiteral__NameAssignment_0 ) ) ;
+    // InternalRoom.g:6014:1: rule__EnumLiteral__Group__0__Impl : ( ( rule__EnumLiteral__NameAssignment_0 ) ) ;
     public final void rule__EnumLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5819:1: ( ( ( rule__EnumLiteral__NameAssignment_0 ) ) )
-            // InternalRoom.g:5820:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
+            // InternalRoom.g:6018:1: ( ( ( rule__EnumLiteral__NameAssignment_0 ) ) )
+            // InternalRoom.g:6019:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
             {
-            // InternalRoom.g:5820:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
-            // InternalRoom.g:5821:1: ( rule__EnumLiteral__NameAssignment_0 )
+            // InternalRoom.g:6019:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
+            // InternalRoom.g:6020:1: ( rule__EnumLiteral__NameAssignment_0 )
             {
              before(grammarAccess.getEnumLiteralAccess().getNameAssignment_0()); 
-            // InternalRoom.g:5822:1: ( rule__EnumLiteral__NameAssignment_0 )
-            // InternalRoom.g:5822:2: rule__EnumLiteral__NameAssignment_0
+            // InternalRoom.g:6021:1: ( rule__EnumLiteral__NameAssignment_0 )
+            // InternalRoom.g:6021:2: rule__EnumLiteral__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__NameAssignment_0();
@@ -17624,14 +18192,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group__1"
-    // InternalRoom.g:5832:1: rule__EnumLiteral__Group__1 : rule__EnumLiteral__Group__1__Impl ;
+    // InternalRoom.g:6031:1: rule__EnumLiteral__Group__1 : rule__EnumLiteral__Group__1__Impl ;
     public final void rule__EnumLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5836:1: ( rule__EnumLiteral__Group__1__Impl )
-            // InternalRoom.g:5837:2: rule__EnumLiteral__Group__1__Impl
+            // InternalRoom.g:6035:1: ( rule__EnumLiteral__Group__1__Impl )
+            // InternalRoom.g:6036:2: rule__EnumLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__Group__1__Impl();
@@ -17657,29 +18225,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group__1__Impl"
-    // InternalRoom.g:5843:1: rule__EnumLiteral__Group__1__Impl : ( ( rule__EnumLiteral__Group_1__0 )? ) ;
+    // InternalRoom.g:6042:1: rule__EnumLiteral__Group__1__Impl : ( ( rule__EnumLiteral__Group_1__0 )? ) ;
     public final void rule__EnumLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5847:1: ( ( ( rule__EnumLiteral__Group_1__0 )? ) )
-            // InternalRoom.g:5848:1: ( ( rule__EnumLiteral__Group_1__0 )? )
+            // InternalRoom.g:6046:1: ( ( ( rule__EnumLiteral__Group_1__0 )? ) )
+            // InternalRoom.g:6047:1: ( ( rule__EnumLiteral__Group_1__0 )? )
             {
-            // InternalRoom.g:5848:1: ( ( rule__EnumLiteral__Group_1__0 )? )
-            // InternalRoom.g:5849:1: ( rule__EnumLiteral__Group_1__0 )?
+            // InternalRoom.g:6047:1: ( ( rule__EnumLiteral__Group_1__0 )? )
+            // InternalRoom.g:6048:1: ( rule__EnumLiteral__Group_1__0 )?
             {
              before(grammarAccess.getEnumLiteralAccess().getGroup_1()); 
-            // InternalRoom.g:5850:1: ( rule__EnumLiteral__Group_1__0 )?
-            int alt65=2;
-            int LA65_0 = input.LA(1);
+            // InternalRoom.g:6049:1: ( rule__EnumLiteral__Group_1__0 )?
+            int alt67=2;
+            int LA67_0 = input.LA(1);
 
-            if ( (LA65_0==55) ) {
-                alt65=1;
+            if ( (LA67_0==55) ) {
+                alt67=1;
             }
-            switch (alt65) {
+            switch (alt67) {
                 case 1 :
-                    // InternalRoom.g:5850:2: rule__EnumLiteral__Group_1__0
+                    // InternalRoom.g:6049:2: rule__EnumLiteral__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumLiteral__Group_1__0();
@@ -17715,14 +18283,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group_1__0"
-    // InternalRoom.g:5864:1: rule__EnumLiteral__Group_1__0 : rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1 ;
+    // InternalRoom.g:6063:1: rule__EnumLiteral__Group_1__0 : rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1 ;
     public final void rule__EnumLiteral__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5868:1: ( rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1 )
-            // InternalRoom.g:5869:2: rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1
+            // InternalRoom.g:6067:1: ( rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1 )
+            // InternalRoom.g:6068:2: rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1
             {
             pushFollow(FOLLOW_21);
             rule__EnumLiteral__Group_1__0__Impl();
@@ -17753,17 +18321,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group_1__0__Impl"
-    // InternalRoom.g:5876:1: rule__EnumLiteral__Group_1__0__Impl : ( '=' ) ;
+    // InternalRoom.g:6075:1: rule__EnumLiteral__Group_1__0__Impl : ( '=' ) ;
     public final void rule__EnumLiteral__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5880:1: ( ( '=' ) )
-            // InternalRoom.g:5881:1: ( '=' )
+            // InternalRoom.g:6079:1: ( ( '=' ) )
+            // InternalRoom.g:6080:1: ( '=' )
             {
-            // InternalRoom.g:5881:1: ( '=' )
-            // InternalRoom.g:5882:1: '='
+            // InternalRoom.g:6080:1: ( '=' )
+            // InternalRoom.g:6081:1: '='
             {
              before(grammarAccess.getEnumLiteralAccess().getEqualsSignKeyword_1_0()); 
             match(input,55,FOLLOW_2); 
@@ -17790,14 +18358,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group_1__1"
-    // InternalRoom.g:5895:1: rule__EnumLiteral__Group_1__1 : rule__EnumLiteral__Group_1__1__Impl ;
+    // InternalRoom.g:6094:1: rule__EnumLiteral__Group_1__1 : rule__EnumLiteral__Group_1__1__Impl ;
     public final void rule__EnumLiteral__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5899:1: ( rule__EnumLiteral__Group_1__1__Impl )
-            // InternalRoom.g:5900:2: rule__EnumLiteral__Group_1__1__Impl
+            // InternalRoom.g:6098:1: ( rule__EnumLiteral__Group_1__1__Impl )
+            // InternalRoom.g:6099:2: rule__EnumLiteral__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__Group_1__1__Impl();
@@ -17823,21 +18391,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__Group_1__1__Impl"
-    // InternalRoom.g:5906:1: rule__EnumLiteral__Group_1__1__Impl : ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) ) ;
+    // InternalRoom.g:6105:1: rule__EnumLiteral__Group_1__1__Impl : ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) ) ;
     public final void rule__EnumLiteral__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5910:1: ( ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) ) )
-            // InternalRoom.g:5911:1: ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) )
+            // InternalRoom.g:6109:1: ( ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) ) )
+            // InternalRoom.g:6110:1: ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) )
             {
-            // InternalRoom.g:5911:1: ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) )
-            // InternalRoom.g:5912:1: ( rule__EnumLiteral__LiteralAssignment_1_1 )
+            // InternalRoom.g:6110:1: ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) )
+            // InternalRoom.g:6111:1: ( rule__EnumLiteral__LiteralAssignment_1_1 )
             {
              before(grammarAccess.getEnumLiteralAccess().getLiteralAssignment_1_1()); 
-            // InternalRoom.g:5913:1: ( rule__EnumLiteral__LiteralAssignment_1_1 )
-            // InternalRoom.g:5913:2: rule__EnumLiteral__LiteralAssignment_1_1
+            // InternalRoom.g:6112:1: ( rule__EnumLiteral__LiteralAssignment_1_1 )
+            // InternalRoom.g:6112:2: rule__EnumLiteral__LiteralAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__LiteralAssignment_1_1();
@@ -17870,14 +18438,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__0"
-    // InternalRoom.g:5927:1: rule__ExternalType__Group__0 : rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1 ;
+    // InternalRoom.g:6126:1: rule__ExternalType__Group__0 : rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1 ;
     public final void rule__ExternalType__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5931:1: ( rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1 )
-            // InternalRoom.g:5932:2: rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1
+            // InternalRoom.g:6130:1: ( rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1 )
+            // InternalRoom.g:6131:2: rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ExternalType__Group__0__Impl();
@@ -17908,17 +18476,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__0__Impl"
-    // InternalRoom.g:5939:1: rule__ExternalType__Group__0__Impl : ( 'ExternalType' ) ;
+    // InternalRoom.g:6138:1: rule__ExternalType__Group__0__Impl : ( 'ExternalType' ) ;
     public final void rule__ExternalType__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5943:1: ( ( 'ExternalType' ) )
-            // InternalRoom.g:5944:1: ( 'ExternalType' )
+            // InternalRoom.g:6142:1: ( ( 'ExternalType' ) )
+            // InternalRoom.g:6143:1: ( 'ExternalType' )
             {
-            // InternalRoom.g:5944:1: ( 'ExternalType' )
-            // InternalRoom.g:5945:1: 'ExternalType'
+            // InternalRoom.g:6143:1: ( 'ExternalType' )
+            // InternalRoom.g:6144:1: 'ExternalType'
             {
              before(grammarAccess.getExternalTypeAccess().getExternalTypeKeyword_0()); 
             match(input,56,FOLLOW_2); 
@@ -17945,14 +18513,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__1"
-    // InternalRoom.g:5958:1: rule__ExternalType__Group__1 : rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2 ;
+    // InternalRoom.g:6157:1: rule__ExternalType__Group__1 : rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2 ;
     public final void rule__ExternalType__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5962:1: ( rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2 )
-            // InternalRoom.g:5963:2: rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2
+            // InternalRoom.g:6161:1: ( rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2 )
+            // InternalRoom.g:6162:2: rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2
             {
             pushFollow(FOLLOW_11);
             rule__ExternalType__Group__1__Impl();
@@ -17983,21 +18551,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__1__Impl"
-    // InternalRoom.g:5970:1: rule__ExternalType__Group__1__Impl : ( ( rule__ExternalType__NameAssignment_1 ) ) ;
+    // InternalRoom.g:6169:1: rule__ExternalType__Group__1__Impl : ( ( rule__ExternalType__NameAssignment_1 ) ) ;
     public final void rule__ExternalType__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5974:1: ( ( ( rule__ExternalType__NameAssignment_1 ) ) )
-            // InternalRoom.g:5975:1: ( ( rule__ExternalType__NameAssignment_1 ) )
+            // InternalRoom.g:6173:1: ( ( ( rule__ExternalType__NameAssignment_1 ) ) )
+            // InternalRoom.g:6174:1: ( ( rule__ExternalType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5975:1: ( ( rule__ExternalType__NameAssignment_1 ) )
-            // InternalRoom.g:5976:1: ( rule__ExternalType__NameAssignment_1 )
+            // InternalRoom.g:6174:1: ( ( rule__ExternalType__NameAssignment_1 ) )
+            // InternalRoom.g:6175:1: ( rule__ExternalType__NameAssignment_1 )
             {
              before(grammarAccess.getExternalTypeAccess().getNameAssignment_1()); 
-            // InternalRoom.g:5977:1: ( rule__ExternalType__NameAssignment_1 )
-            // InternalRoom.g:5977:2: rule__ExternalType__NameAssignment_1
+            // InternalRoom.g:6176:1: ( rule__ExternalType__NameAssignment_1 )
+            // InternalRoom.g:6176:2: rule__ExternalType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__NameAssignment_1();
@@ -18030,14 +18598,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__2"
-    // InternalRoom.g:5987:1: rule__ExternalType__Group__2 : rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3 ;
+    // InternalRoom.g:6186:1: rule__ExternalType__Group__2 : rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3 ;
     public final void rule__ExternalType__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:5991:1: ( rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3 )
-            // InternalRoom.g:5992:2: rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3
+            // InternalRoom.g:6190:1: ( rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3 )
+            // InternalRoom.g:6191:2: rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3
             {
             pushFollow(FOLLOW_12);
             rule__ExternalType__Group__2__Impl();
@@ -18068,17 +18636,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__2__Impl"
-    // InternalRoom.g:5999:1: rule__ExternalType__Group__2__Impl : ( '->' ) ;
+    // InternalRoom.g:6198:1: rule__ExternalType__Group__2__Impl : ( '->' ) ;
     public final void rule__ExternalType__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6003:1: ( ( '->' ) )
-            // InternalRoom.g:6004:1: ( '->' )
+            // InternalRoom.g:6202:1: ( ( '->' ) )
+            // InternalRoom.g:6203:1: ( '->' )
             {
-            // InternalRoom.g:6004:1: ( '->' )
-            // InternalRoom.g:6005:1: '->'
+            // InternalRoom.g:6203:1: ( '->' )
+            // InternalRoom.g:6204:1: '->'
             {
              before(grammarAccess.getExternalTypeAccess().getHyphenMinusGreaterThanSignKeyword_2()); 
             match(input,48,FOLLOW_2); 
@@ -18105,14 +18673,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__3"
-    // InternalRoom.g:6018:1: rule__ExternalType__Group__3 : rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4 ;
+    // InternalRoom.g:6217:1: rule__ExternalType__Group__3 : rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4 ;
     public final void rule__ExternalType__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6022:1: ( rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4 )
-            // InternalRoom.g:6023:2: rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4
+            // InternalRoom.g:6221:1: ( rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4 )
+            // InternalRoom.g:6222:2: rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4
             {
             pushFollow(FOLLOW_22);
             rule__ExternalType__Group__3__Impl();
@@ -18143,21 +18711,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__3__Impl"
-    // InternalRoom.g:6030:1: rule__ExternalType__Group__3__Impl : ( ( rule__ExternalType__TargetNameAssignment_3 ) ) ;
+    // InternalRoom.g:6229:1: rule__ExternalType__Group__3__Impl : ( ( rule__ExternalType__TargetNameAssignment_3 ) ) ;
     public final void rule__ExternalType__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6034:1: ( ( ( rule__ExternalType__TargetNameAssignment_3 ) ) )
-            // InternalRoom.g:6035:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
+            // InternalRoom.g:6233:1: ( ( ( rule__ExternalType__TargetNameAssignment_3 ) ) )
+            // InternalRoom.g:6234:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
             {
-            // InternalRoom.g:6035:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
-            // InternalRoom.g:6036:1: ( rule__ExternalType__TargetNameAssignment_3 )
+            // InternalRoom.g:6234:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
+            // InternalRoom.g:6235:1: ( rule__ExternalType__TargetNameAssignment_3 )
             {
              before(grammarAccess.getExternalTypeAccess().getTargetNameAssignment_3()); 
-            // InternalRoom.g:6037:1: ( rule__ExternalType__TargetNameAssignment_3 )
-            // InternalRoom.g:6037:2: rule__ExternalType__TargetNameAssignment_3
+            // InternalRoom.g:6236:1: ( rule__ExternalType__TargetNameAssignment_3 )
+            // InternalRoom.g:6236:2: rule__ExternalType__TargetNameAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__TargetNameAssignment_3();
@@ -18190,14 +18758,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__4"
-    // InternalRoom.g:6047:1: rule__ExternalType__Group__4 : rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5 ;
+    // InternalRoom.g:6246:1: rule__ExternalType__Group__4 : rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5 ;
     public final void rule__ExternalType__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6051:1: ( rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5 )
-            // InternalRoom.g:6052:2: rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5
+            // InternalRoom.g:6250:1: ( rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5 )
+            // InternalRoom.g:6251:2: rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5
             {
             pushFollow(FOLLOW_22);
             rule__ExternalType__Group__4__Impl();
@@ -18228,29 +18796,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__4__Impl"
-    // InternalRoom.g:6059:1: rule__ExternalType__Group__4__Impl : ( ( rule__ExternalType__Group_4__0 )? ) ;
+    // InternalRoom.g:6258:1: rule__ExternalType__Group__4__Impl : ( ( rule__ExternalType__Group_4__0 )? ) ;
     public final void rule__ExternalType__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6063:1: ( ( ( rule__ExternalType__Group_4__0 )? ) )
-            // InternalRoom.g:6064:1: ( ( rule__ExternalType__Group_4__0 )? )
+            // InternalRoom.g:6262:1: ( ( ( rule__ExternalType__Group_4__0 )? ) )
+            // InternalRoom.g:6263:1: ( ( rule__ExternalType__Group_4__0 )? )
             {
-            // InternalRoom.g:6064:1: ( ( rule__ExternalType__Group_4__0 )? )
-            // InternalRoom.g:6065:1: ( rule__ExternalType__Group_4__0 )?
+            // InternalRoom.g:6263:1: ( ( rule__ExternalType__Group_4__0 )? )
+            // InternalRoom.g:6264:1: ( rule__ExternalType__Group_4__0 )?
             {
              before(grammarAccess.getExternalTypeAccess().getGroup_4()); 
-            // InternalRoom.g:6066:1: ( rule__ExternalType__Group_4__0 )?
-            int alt66=2;
-            int LA66_0 = input.LA(1);
+            // InternalRoom.g:6265:1: ( rule__ExternalType__Group_4__0 )?
+            int alt68=2;
+            int LA68_0 = input.LA(1);
 
-            if ( (LA66_0==49) ) {
-                alt66=1;
+            if ( (LA68_0==49) ) {
+                alt68=1;
             }
-            switch (alt66) {
+            switch (alt68) {
                 case 1 :
-                    // InternalRoom.g:6066:2: rule__ExternalType__Group_4__0
+                    // InternalRoom.g:6265:2: rule__ExternalType__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ExternalType__Group_4__0();
@@ -18286,14 +18854,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__5"
-    // InternalRoom.g:6076:1: rule__ExternalType__Group__5 : rule__ExternalType__Group__5__Impl ;
+    // InternalRoom.g:6275:1: rule__ExternalType__Group__5 : rule__ExternalType__Group__5__Impl ;
     public final void rule__ExternalType__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6080:1: ( rule__ExternalType__Group__5__Impl )
-            // InternalRoom.g:6081:2: rule__ExternalType__Group__5__Impl
+            // InternalRoom.g:6279:1: ( rule__ExternalType__Group__5__Impl )
+            // InternalRoom.g:6280:2: rule__ExternalType__Group__5__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__Group__5__Impl();
@@ -18319,29 +18887,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__5__Impl"
-    // InternalRoom.g:6087:1: rule__ExternalType__Group__5__Impl : ( ( rule__ExternalType__DocuAssignment_5 )? ) ;
+    // InternalRoom.g:6286:1: rule__ExternalType__Group__5__Impl : ( ( rule__ExternalType__DocuAssignment_5 )? ) ;
     public final void rule__ExternalType__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6091:1: ( ( ( rule__ExternalType__DocuAssignment_5 )? ) )
-            // InternalRoom.g:6092:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
+            // InternalRoom.g:6290:1: ( ( ( rule__ExternalType__DocuAssignment_5 )? ) )
+            // InternalRoom.g:6291:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
             {
-            // InternalRoom.g:6092:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
-            // InternalRoom.g:6093:1: ( rule__ExternalType__DocuAssignment_5 )?
+            // InternalRoom.g:6291:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
+            // InternalRoom.g:6292:1: ( rule__ExternalType__DocuAssignment_5 )?
             {
              before(grammarAccess.getExternalTypeAccess().getDocuAssignment_5()); 
-            // InternalRoom.g:6094:1: ( rule__ExternalType__DocuAssignment_5 )?
-            int alt67=2;
-            int LA67_0 = input.LA(1);
+            // InternalRoom.g:6293:1: ( rule__ExternalType__DocuAssignment_5 )?
+            int alt69=2;
+            int LA69_0 = input.LA(1);
 
-            if ( (LA67_0==62) ) {
-                alt67=1;
+            if ( (LA69_0==62) ) {
+                alt69=1;
             }
-            switch (alt67) {
+            switch (alt69) {
                 case 1 :
-                    // InternalRoom.g:6094:2: rule__ExternalType__DocuAssignment_5
+                    // InternalRoom.g:6293:2: rule__ExternalType__DocuAssignment_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ExternalType__DocuAssignment_5();
@@ -18377,14 +18945,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group_4__0"
-    // InternalRoom.g:6116:1: rule__ExternalType__Group_4__0 : rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1 ;
+    // InternalRoom.g:6315:1: rule__ExternalType__Group_4__0 : rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1 ;
     public final void rule__ExternalType__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6120:1: ( rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1 )
-            // InternalRoom.g:6121:2: rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1
+            // InternalRoom.g:6319:1: ( rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1 )
+            // InternalRoom.g:6320:2: rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1
             {
             pushFollow(FOLLOW_12);
             rule__ExternalType__Group_4__0__Impl();
@@ -18415,17 +18983,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group_4__0__Impl"
-    // InternalRoom.g:6128:1: rule__ExternalType__Group_4__0__Impl : ( 'default' ) ;
+    // InternalRoom.g:6327:1: rule__ExternalType__Group_4__0__Impl : ( 'default' ) ;
     public final void rule__ExternalType__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6132:1: ( ( 'default' ) )
-            // InternalRoom.g:6133:1: ( 'default' )
+            // InternalRoom.g:6331:1: ( ( 'default' ) )
+            // InternalRoom.g:6332:1: ( 'default' )
             {
-            // InternalRoom.g:6133:1: ( 'default' )
-            // InternalRoom.g:6134:1: 'default'
+            // InternalRoom.g:6332:1: ( 'default' )
+            // InternalRoom.g:6333:1: 'default'
             {
              before(grammarAccess.getExternalTypeAccess().getDefaultKeyword_4_0()); 
             match(input,49,FOLLOW_2); 
@@ -18452,14 +19020,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group_4__1"
-    // InternalRoom.g:6147:1: rule__ExternalType__Group_4__1 : rule__ExternalType__Group_4__1__Impl ;
+    // InternalRoom.g:6346:1: rule__ExternalType__Group_4__1 : rule__ExternalType__Group_4__1__Impl ;
     public final void rule__ExternalType__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6151:1: ( rule__ExternalType__Group_4__1__Impl )
-            // InternalRoom.g:6152:2: rule__ExternalType__Group_4__1__Impl
+            // InternalRoom.g:6350:1: ( rule__ExternalType__Group_4__1__Impl )
+            // InternalRoom.g:6351:2: rule__ExternalType__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__Group_4__1__Impl();
@@ -18485,21 +19053,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group_4__1__Impl"
-    // InternalRoom.g:6158:1: rule__ExternalType__Group_4__1__Impl : ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) ) ;
+    // InternalRoom.g:6357:1: rule__ExternalType__Group_4__1__Impl : ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) ) ;
     public final void rule__ExternalType__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6162:1: ( ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) ) )
-            // InternalRoom.g:6163:1: ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) )
+            // InternalRoom.g:6361:1: ( ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) ) )
+            // InternalRoom.g:6362:1: ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) )
             {
-            // InternalRoom.g:6163:1: ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) )
-            // InternalRoom.g:6164:1: ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 )
+            // InternalRoom.g:6362:1: ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) )
+            // InternalRoom.g:6363:1: ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 )
             {
              before(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralAssignment_4_1()); 
-            // InternalRoom.g:6165:1: ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 )
-            // InternalRoom.g:6165:2: rule__ExternalType__DefaultValueLiteralAssignment_4_1
+            // InternalRoom.g:6364:1: ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 )
+            // InternalRoom.g:6364:2: rule__ExternalType__DefaultValueLiteralAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__DefaultValueLiteralAssignment_4_1();
@@ -18532,14 +19100,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__0"
-    // InternalRoom.g:6179:1: rule__DataClass__Group__0 : rule__DataClass__Group__0__Impl rule__DataClass__Group__1 ;
+    // InternalRoom.g:6378:1: rule__DataClass__Group__0 : rule__DataClass__Group__0__Impl rule__DataClass__Group__1 ;
     public final void rule__DataClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6183:1: ( rule__DataClass__Group__0__Impl rule__DataClass__Group__1 )
-            // InternalRoom.g:6184:2: rule__DataClass__Group__0__Impl rule__DataClass__Group__1
+            // InternalRoom.g:6382:1: ( rule__DataClass__Group__0__Impl rule__DataClass__Group__1 )
+            // InternalRoom.g:6383:2: rule__DataClass__Group__0__Impl rule__DataClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__DataClass__Group__0__Impl();
@@ -18570,17 +19138,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__0__Impl"
-    // InternalRoom.g:6191:1: rule__DataClass__Group__0__Impl : ( 'DataClass' ) ;
+    // InternalRoom.g:6390:1: rule__DataClass__Group__0__Impl : ( 'DataClass' ) ;
     public final void rule__DataClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6195:1: ( ( 'DataClass' ) )
-            // InternalRoom.g:6196:1: ( 'DataClass' )
+            // InternalRoom.g:6394:1: ( ( 'DataClass' ) )
+            // InternalRoom.g:6395:1: ( 'DataClass' )
             {
-            // InternalRoom.g:6196:1: ( 'DataClass' )
-            // InternalRoom.g:6197:1: 'DataClass'
+            // InternalRoom.g:6395:1: ( 'DataClass' )
+            // InternalRoom.g:6396:1: 'DataClass'
             {
              before(grammarAccess.getDataClassAccess().getDataClassKeyword_0()); 
             match(input,17,FOLLOW_2); 
@@ -18607,14 +19175,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__1"
-    // InternalRoom.g:6210:1: rule__DataClass__Group__1 : rule__DataClass__Group__1__Impl rule__DataClass__Group__2 ;
+    // InternalRoom.g:6409:1: rule__DataClass__Group__1 : rule__DataClass__Group__1__Impl rule__DataClass__Group__2 ;
     public final void rule__DataClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6214:1: ( rule__DataClass__Group__1__Impl rule__DataClass__Group__2 )
-            // InternalRoom.g:6215:2: rule__DataClass__Group__1__Impl rule__DataClass__Group__2
+            // InternalRoom.g:6413:1: ( rule__DataClass__Group__1__Impl rule__DataClass__Group__2 )
+            // InternalRoom.g:6414:2: rule__DataClass__Group__1__Impl rule__DataClass__Group__2
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__1__Impl();
@@ -18645,21 +19213,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__1__Impl"
-    // InternalRoom.g:6222:1: rule__DataClass__Group__1__Impl : ( ( rule__DataClass__NameAssignment_1 ) ) ;
+    // InternalRoom.g:6421:1: rule__DataClass__Group__1__Impl : ( ( rule__DataClass__NameAssignment_1 ) ) ;
     public final void rule__DataClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6226:1: ( ( ( rule__DataClass__NameAssignment_1 ) ) )
-            // InternalRoom.g:6227:1: ( ( rule__DataClass__NameAssignment_1 ) )
+            // InternalRoom.g:6425:1: ( ( ( rule__DataClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:6426:1: ( ( rule__DataClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:6227:1: ( ( rule__DataClass__NameAssignment_1 ) )
-            // InternalRoom.g:6228:1: ( rule__DataClass__NameAssignment_1 )
+            // InternalRoom.g:6426:1: ( ( rule__DataClass__NameAssignment_1 ) )
+            // InternalRoom.g:6427:1: ( rule__DataClass__NameAssignment_1 )
             {
              before(grammarAccess.getDataClassAccess().getNameAssignment_1()); 
-            // InternalRoom.g:6229:1: ( rule__DataClass__NameAssignment_1 )
-            // InternalRoom.g:6229:2: rule__DataClass__NameAssignment_1
+            // InternalRoom.g:6428:1: ( rule__DataClass__NameAssignment_1 )
+            // InternalRoom.g:6428:2: rule__DataClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__NameAssignment_1();
@@ -18692,14 +19260,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__2"
-    // InternalRoom.g:6239:1: rule__DataClass__Group__2 : rule__DataClass__Group__2__Impl rule__DataClass__Group__3 ;
+    // InternalRoom.g:6438:1: rule__DataClass__Group__2 : rule__DataClass__Group__2__Impl rule__DataClass__Group__3 ;
     public final void rule__DataClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6243:1: ( rule__DataClass__Group__2__Impl rule__DataClass__Group__3 )
-            // InternalRoom.g:6244:2: rule__DataClass__Group__2__Impl rule__DataClass__Group__3
+            // InternalRoom.g:6442:1: ( rule__DataClass__Group__2__Impl rule__DataClass__Group__3 )
+            // InternalRoom.g:6443:2: rule__DataClass__Group__2__Impl rule__DataClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__2__Impl();
@@ -18730,29 +19298,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__2__Impl"
-    // InternalRoom.g:6251:1: rule__DataClass__Group__2__Impl : ( ( rule__DataClass__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:6450:1: rule__DataClass__Group__2__Impl : ( ( rule__DataClass__DocuAssignment_2 )? ) ;
     public final void rule__DataClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6255:1: ( ( ( rule__DataClass__DocuAssignment_2 )? ) )
-            // InternalRoom.g:6256:1: ( ( rule__DataClass__DocuAssignment_2 )? )
+            // InternalRoom.g:6454:1: ( ( ( rule__DataClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:6455:1: ( ( rule__DataClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:6256:1: ( ( rule__DataClass__DocuAssignment_2 )? )
-            // InternalRoom.g:6257:1: ( rule__DataClass__DocuAssignment_2 )?
+            // InternalRoom.g:6455:1: ( ( rule__DataClass__DocuAssignment_2 )? )
+            // InternalRoom.g:6456:1: ( rule__DataClass__DocuAssignment_2 )?
             {
              before(grammarAccess.getDataClassAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:6258:1: ( rule__DataClass__DocuAssignment_2 )?
-            int alt68=2;
-            int LA68_0 = input.LA(1);
+            // InternalRoom.g:6457:1: ( rule__DataClass__DocuAssignment_2 )?
+            int alt70=2;
+            int LA70_0 = input.LA(1);
 
-            if ( (LA68_0==62) ) {
-                alt68=1;
+            if ( (LA70_0==62) ) {
+                alt70=1;
             }
-            switch (alt68) {
+            switch (alt70) {
                 case 1 :
-                    // InternalRoom.g:6258:2: rule__DataClass__DocuAssignment_2
+                    // InternalRoom.g:6457:2: rule__DataClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__DocuAssignment_2();
@@ -18788,14 +19356,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__3"
-    // InternalRoom.g:6268:1: rule__DataClass__Group__3 : rule__DataClass__Group__3__Impl rule__DataClass__Group__4 ;
+    // InternalRoom.g:6467:1: rule__DataClass__Group__3 : rule__DataClass__Group__3__Impl rule__DataClass__Group__4 ;
     public final void rule__DataClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6272:1: ( rule__DataClass__Group__3__Impl rule__DataClass__Group__4 )
-            // InternalRoom.g:6273:2: rule__DataClass__Group__3__Impl rule__DataClass__Group__4
+            // InternalRoom.g:6471:1: ( rule__DataClass__Group__3__Impl rule__DataClass__Group__4 )
+            // InternalRoom.g:6472:2: rule__DataClass__Group__3__Impl rule__DataClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__3__Impl();
@@ -18826,29 +19394,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__3__Impl"
-    // InternalRoom.g:6280:1: rule__DataClass__Group__3__Impl : ( ( rule__DataClass__Group_3__0 )? ) ;
+    // InternalRoom.g:6479:1: rule__DataClass__Group__3__Impl : ( ( rule__DataClass__Group_3__0 )? ) ;
     public final void rule__DataClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6284:1: ( ( ( rule__DataClass__Group_3__0 )? ) )
-            // InternalRoom.g:6285:1: ( ( rule__DataClass__Group_3__0 )? )
+            // InternalRoom.g:6483:1: ( ( ( rule__DataClass__Group_3__0 )? ) )
+            // InternalRoom.g:6484:1: ( ( rule__DataClass__Group_3__0 )? )
             {
-            // InternalRoom.g:6285:1: ( ( rule__DataClass__Group_3__0 )? )
-            // InternalRoom.g:6286:1: ( rule__DataClass__Group_3__0 )?
+            // InternalRoom.g:6484:1: ( ( rule__DataClass__Group_3__0 )? )
+            // InternalRoom.g:6485:1: ( rule__DataClass__Group_3__0 )?
             {
              before(grammarAccess.getDataClassAccess().getGroup_3()); 
-            // InternalRoom.g:6287:1: ( rule__DataClass__Group_3__0 )?
-            int alt69=2;
-            int LA69_0 = input.LA(1);
+            // InternalRoom.g:6486:1: ( rule__DataClass__Group_3__0 )?
+            int alt71=2;
+            int LA71_0 = input.LA(1);
 
-            if ( (LA69_0==57) ) {
-                alt69=1;
+            if ( (LA71_0==57) ) {
+                alt71=1;
             }
-            switch (alt69) {
+            switch (alt71) {
                 case 1 :
-                    // InternalRoom.g:6287:2: rule__DataClass__Group_3__0
+                    // InternalRoom.g:6486:2: rule__DataClass__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_3__0();
@@ -18884,14 +19452,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__4"
-    // InternalRoom.g:6297:1: rule__DataClass__Group__4 : rule__DataClass__Group__4__Impl rule__DataClass__Group__5 ;
+    // InternalRoom.g:6496:1: rule__DataClass__Group__4 : rule__DataClass__Group__4__Impl rule__DataClass__Group__5 ;
     public final void rule__DataClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6301:1: ( rule__DataClass__Group__4__Impl rule__DataClass__Group__5 )
-            // InternalRoom.g:6302:2: rule__DataClass__Group__4__Impl rule__DataClass__Group__5
+            // InternalRoom.g:6500:1: ( rule__DataClass__Group__4__Impl rule__DataClass__Group__5 )
+            // InternalRoom.g:6501:2: rule__DataClass__Group__4__Impl rule__DataClass__Group__5
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__4__Impl();
@@ -18922,17 +19490,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__4__Impl"
-    // InternalRoom.g:6309:1: rule__DataClass__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:6508:1: rule__DataClass__Group__4__Impl : ( '{' ) ;
     public final void rule__DataClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6313:1: ( ( '{' ) )
-            // InternalRoom.g:6314:1: ( '{' )
+            // InternalRoom.g:6512:1: ( ( '{' ) )
+            // InternalRoom.g:6513:1: ( '{' )
             {
-            // InternalRoom.g:6314:1: ( '{' )
-            // InternalRoom.g:6315:1: '{'
+            // InternalRoom.g:6513:1: ( '{' )
+            // InternalRoom.g:6514:1: '{'
             {
              before(grammarAccess.getDataClassAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -18959,14 +19527,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__5"
-    // InternalRoom.g:6328:1: rule__DataClass__Group__5 : rule__DataClass__Group__5__Impl rule__DataClass__Group__6 ;
+    // InternalRoom.g:6527:1: rule__DataClass__Group__5 : rule__DataClass__Group__5__Impl rule__DataClass__Group__6 ;
     public final void rule__DataClass__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6332:1: ( rule__DataClass__Group__5__Impl rule__DataClass__Group__6 )
-            // InternalRoom.g:6333:2: rule__DataClass__Group__5__Impl rule__DataClass__Group__6
+            // InternalRoom.g:6531:1: ( rule__DataClass__Group__5__Impl rule__DataClass__Group__6 )
+            // InternalRoom.g:6532:2: rule__DataClass__Group__5__Impl rule__DataClass__Group__6
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__5__Impl();
@@ -18997,33 +19565,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__5__Impl"
-    // InternalRoom.g:6340:1: rule__DataClass__Group__5__Impl : ( ( rule__DataClass__AnnotationsAssignment_5 )* ) ;
+    // InternalRoom.g:6539:1: rule__DataClass__Group__5__Impl : ( ( rule__DataClass__AnnotationsAssignment_5 )* ) ;
     public final void rule__DataClass__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6344:1: ( ( ( rule__DataClass__AnnotationsAssignment_5 )* ) )
-            // InternalRoom.g:6345:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
+            // InternalRoom.g:6543:1: ( ( ( rule__DataClass__AnnotationsAssignment_5 )* ) )
+            // InternalRoom.g:6544:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
             {
-            // InternalRoom.g:6345:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
-            // InternalRoom.g:6346:1: ( rule__DataClass__AnnotationsAssignment_5 )*
+            // InternalRoom.g:6544:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
+            // InternalRoom.g:6545:1: ( rule__DataClass__AnnotationsAssignment_5 )*
             {
              before(grammarAccess.getDataClassAccess().getAnnotationsAssignment_5()); 
-            // InternalRoom.g:6347:1: ( rule__DataClass__AnnotationsAssignment_5 )*
-            loop70:
+            // InternalRoom.g:6546:1: ( rule__DataClass__AnnotationsAssignment_5 )*
+            loop72:
             do {
-                int alt70=2;
-                int LA70_0 = input.LA(1);
+                int alt72=2;
+                int LA72_0 = input.LA(1);
 
-                if ( (LA70_0==121) ) {
-                    alt70=1;
+                if ( (LA72_0==121) ) {
+                    alt72=1;
                 }
 
 
-                switch (alt70) {
+                switch (alt72) {
             	case 1 :
-            	    // InternalRoom.g:6347:2: rule__DataClass__AnnotationsAssignment_5
+            	    // InternalRoom.g:6546:2: rule__DataClass__AnnotationsAssignment_5
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__DataClass__AnnotationsAssignment_5();
@@ -19035,7 +19603,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop70;
+            	    break loop72;
                 }
             } while (true);
 
@@ -19062,14 +19630,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__6"
-    // InternalRoom.g:6357:1: rule__DataClass__Group__6 : rule__DataClass__Group__6__Impl rule__DataClass__Group__7 ;
+    // InternalRoom.g:6556:1: rule__DataClass__Group__6 : rule__DataClass__Group__6__Impl rule__DataClass__Group__7 ;
     public final void rule__DataClass__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6361:1: ( rule__DataClass__Group__6__Impl rule__DataClass__Group__7 )
-            // InternalRoom.g:6362:2: rule__DataClass__Group__6__Impl rule__DataClass__Group__7
+            // InternalRoom.g:6560:1: ( rule__DataClass__Group__6__Impl rule__DataClass__Group__7 )
+            // InternalRoom.g:6561:2: rule__DataClass__Group__6__Impl rule__DataClass__Group__7
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__6__Impl();
@@ -19100,29 +19668,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__6__Impl"
-    // InternalRoom.g:6369:1: rule__DataClass__Group__6__Impl : ( ( rule__DataClass__Group_6__0 )? ) ;
+    // InternalRoom.g:6568:1: rule__DataClass__Group__6__Impl : ( ( rule__DataClass__Group_6__0 )? ) ;
     public final void rule__DataClass__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6373:1: ( ( ( rule__DataClass__Group_6__0 )? ) )
-            // InternalRoom.g:6374:1: ( ( rule__DataClass__Group_6__0 )? )
+            // InternalRoom.g:6572:1: ( ( ( rule__DataClass__Group_6__0 )? ) )
+            // InternalRoom.g:6573:1: ( ( rule__DataClass__Group_6__0 )? )
             {
-            // InternalRoom.g:6374:1: ( ( rule__DataClass__Group_6__0 )? )
-            // InternalRoom.g:6375:1: ( rule__DataClass__Group_6__0 )?
+            // InternalRoom.g:6573:1: ( ( rule__DataClass__Group_6__0 )? )
+            // InternalRoom.g:6574:1: ( rule__DataClass__Group_6__0 )?
             {
              before(grammarAccess.getDataClassAccess().getGroup_6()); 
-            // InternalRoom.g:6376:1: ( rule__DataClass__Group_6__0 )?
-            int alt71=2;
-            int LA71_0 = input.LA(1);
+            // InternalRoom.g:6575:1: ( rule__DataClass__Group_6__0 )?
+            int alt73=2;
+            int LA73_0 = input.LA(1);
 
-            if ( (LA71_0==58) ) {
-                alt71=1;
+            if ( (LA73_0==58) ) {
+                alt73=1;
             }
-            switch (alt71) {
+            switch (alt73) {
                 case 1 :
-                    // InternalRoom.g:6376:2: rule__DataClass__Group_6__0
+                    // InternalRoom.g:6575:2: rule__DataClass__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_6__0();
@@ -19158,14 +19726,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__7"
-    // InternalRoom.g:6386:1: rule__DataClass__Group__7 : rule__DataClass__Group__7__Impl rule__DataClass__Group__8 ;
+    // InternalRoom.g:6585:1: rule__DataClass__Group__7 : rule__DataClass__Group__7__Impl rule__DataClass__Group__8 ;
     public final void rule__DataClass__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6390:1: ( rule__DataClass__Group__7__Impl rule__DataClass__Group__8 )
-            // InternalRoom.g:6391:2: rule__DataClass__Group__7__Impl rule__DataClass__Group__8
+            // InternalRoom.g:6589:1: ( rule__DataClass__Group__7__Impl rule__DataClass__Group__8 )
+            // InternalRoom.g:6590:2: rule__DataClass__Group__7__Impl rule__DataClass__Group__8
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__7__Impl();
@@ -19196,29 +19764,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__7__Impl"
-    // InternalRoom.g:6398:1: rule__DataClass__Group__7__Impl : ( ( rule__DataClass__Group_7__0 )? ) ;
+    // InternalRoom.g:6597:1: rule__DataClass__Group__7__Impl : ( ( rule__DataClass__Group_7__0 )? ) ;
     public final void rule__DataClass__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6402:1: ( ( ( rule__DataClass__Group_7__0 )? ) )
-            // InternalRoom.g:6403:1: ( ( rule__DataClass__Group_7__0 )? )
+            // InternalRoom.g:6601:1: ( ( ( rule__DataClass__Group_7__0 )? ) )
+            // InternalRoom.g:6602:1: ( ( rule__DataClass__Group_7__0 )? )
             {
-            // InternalRoom.g:6403:1: ( ( rule__DataClass__Group_7__0 )? )
-            // InternalRoom.g:6404:1: ( rule__DataClass__Group_7__0 )?
+            // InternalRoom.g:6602:1: ( ( rule__DataClass__Group_7__0 )? )
+            // InternalRoom.g:6603:1: ( rule__DataClass__Group_7__0 )?
             {
              before(grammarAccess.getDataClassAccess().getGroup_7()); 
-            // InternalRoom.g:6405:1: ( rule__DataClass__Group_7__0 )?
-            int alt72=2;
-            int LA72_0 = input.LA(1);
+            // InternalRoom.g:6604:1: ( rule__DataClass__Group_7__0 )?
+            int alt74=2;
+            int LA74_0 = input.LA(1);
 
-            if ( (LA72_0==59) ) {
-                alt72=1;
+            if ( (LA74_0==59) ) {
+                alt74=1;
             }
-            switch (alt72) {
+            switch (alt74) {
                 case 1 :
-                    // InternalRoom.g:6405:2: rule__DataClass__Group_7__0
+                    // InternalRoom.g:6604:2: rule__DataClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_7__0();
@@ -19254,14 +19822,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__8"
-    // InternalRoom.g:6415:1: rule__DataClass__Group__8 : rule__DataClass__Group__8__Impl rule__DataClass__Group__9 ;
+    // InternalRoom.g:6614:1: rule__DataClass__Group__8 : rule__DataClass__Group__8__Impl rule__DataClass__Group__9 ;
     public final void rule__DataClass__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6419:1: ( rule__DataClass__Group__8__Impl rule__DataClass__Group__9 )
-            // InternalRoom.g:6420:2: rule__DataClass__Group__8__Impl rule__DataClass__Group__9
+            // InternalRoom.g:6618:1: ( rule__DataClass__Group__8__Impl rule__DataClass__Group__9 )
+            // InternalRoom.g:6619:2: rule__DataClass__Group__8__Impl rule__DataClass__Group__9
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__8__Impl();
@@ -19292,29 +19860,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__8__Impl"
-    // InternalRoom.g:6427:1: rule__DataClass__Group__8__Impl : ( ( rule__DataClass__Group_8__0 )? ) ;
+    // InternalRoom.g:6626:1: rule__DataClass__Group__8__Impl : ( ( rule__DataClass__Group_8__0 )? ) ;
     public final void rule__DataClass__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6431:1: ( ( ( rule__DataClass__Group_8__0 )? ) )
-            // InternalRoom.g:6432:1: ( ( rule__DataClass__Group_8__0 )? )
+            // InternalRoom.g:6630:1: ( ( ( rule__DataClass__Group_8__0 )? ) )
+            // InternalRoom.g:6631:1: ( ( rule__DataClass__Group_8__0 )? )
             {
-            // InternalRoom.g:6432:1: ( ( rule__DataClass__Group_8__0 )? )
-            // InternalRoom.g:6433:1: ( rule__DataClass__Group_8__0 )?
+            // InternalRoom.g:6631:1: ( ( rule__DataClass__Group_8__0 )? )
+            // InternalRoom.g:6632:1: ( rule__DataClass__Group_8__0 )?
             {
              before(grammarAccess.getDataClassAccess().getGroup_8()); 
-            // InternalRoom.g:6434:1: ( rule__DataClass__Group_8__0 )?
-            int alt73=2;
-            int LA73_0 = input.LA(1);
+            // InternalRoom.g:6633:1: ( rule__DataClass__Group_8__0 )?
+            int alt75=2;
+            int LA75_0 = input.LA(1);
 
-            if ( (LA73_0==60) ) {
-                alt73=1;
+            if ( (LA75_0==60) ) {
+                alt75=1;
             }
-            switch (alt73) {
+            switch (alt75) {
                 case 1 :
-                    // InternalRoom.g:6434:2: rule__DataClass__Group_8__0
+                    // InternalRoom.g:6633:2: rule__DataClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_8__0();
@@ -19350,14 +19918,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__9"
-    // InternalRoom.g:6444:1: rule__DataClass__Group__9 : rule__DataClass__Group__9__Impl rule__DataClass__Group__10 ;
+    // InternalRoom.g:6643:1: rule__DataClass__Group__9 : rule__DataClass__Group__9__Impl rule__DataClass__Group__10 ;
     public final void rule__DataClass__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6448:1: ( rule__DataClass__Group__9__Impl rule__DataClass__Group__10 )
-            // InternalRoom.g:6449:2: rule__DataClass__Group__9__Impl rule__DataClass__Group__10
+            // InternalRoom.g:6647:1: ( rule__DataClass__Group__9__Impl rule__DataClass__Group__10 )
+            // InternalRoom.g:6648:2: rule__DataClass__Group__9__Impl rule__DataClass__Group__10
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__9__Impl();
@@ -19388,33 +19956,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__9__Impl"
-    // InternalRoom.g:6456:1: rule__DataClass__Group__9__Impl : ( ( rule__DataClass__Alternatives_9 )* ) ;
+    // InternalRoom.g:6655:1: rule__DataClass__Group__9__Impl : ( ( rule__DataClass__Alternatives_9 )* ) ;
     public final void rule__DataClass__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6460:1: ( ( ( rule__DataClass__Alternatives_9 )* ) )
-            // InternalRoom.g:6461:1: ( ( rule__DataClass__Alternatives_9 )* )
+            // InternalRoom.g:6659:1: ( ( ( rule__DataClass__Alternatives_9 )* ) )
+            // InternalRoom.g:6660:1: ( ( rule__DataClass__Alternatives_9 )* )
             {
-            // InternalRoom.g:6461:1: ( ( rule__DataClass__Alternatives_9 )* )
-            // InternalRoom.g:6462:1: ( rule__DataClass__Alternatives_9 )*
+            // InternalRoom.g:6660:1: ( ( rule__DataClass__Alternatives_9 )* )
+            // InternalRoom.g:6661:1: ( rule__DataClass__Alternatives_9 )*
             {
              before(grammarAccess.getDataClassAccess().getAlternatives_9()); 
-            // InternalRoom.g:6463:1: ( rule__DataClass__Alternatives_9 )*
-            loop74:
+            // InternalRoom.g:6662:1: ( rule__DataClass__Alternatives_9 )*
+            loop76:
             do {
-                int alt74=2;
-                int LA74_0 = input.LA(1);
+                int alt76=2;
+                int LA76_0 = input.LA(1);
 
-                if ( ((LA74_0>=14 && LA74_0<=15)||LA74_0==61||LA74_0==64||LA74_0==128) ) {
-                    alt74=1;
+                if ( ((LA76_0>=14 && LA76_0<=15)||LA76_0==61||LA76_0==64||LA76_0==128) ) {
+                    alt76=1;
                 }
 
 
-                switch (alt74) {
+                switch (alt76) {
             	case 1 :
-            	    // InternalRoom.g:6463:2: rule__DataClass__Alternatives_9
+            	    // InternalRoom.g:6662:2: rule__DataClass__Alternatives_9
             	    {
             	    pushFollow(FOLLOW_26);
             	    rule__DataClass__Alternatives_9();
@@ -19426,7 +19994,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop74;
+            	    break loop76;
                 }
             } while (true);
 
@@ -19453,14 +20021,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__10"
-    // InternalRoom.g:6473:1: rule__DataClass__Group__10 : rule__DataClass__Group__10__Impl ;
+    // InternalRoom.g:6672:1: rule__DataClass__Group__10 : rule__DataClass__Group__10__Impl ;
     public final void rule__DataClass__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6477:1: ( rule__DataClass__Group__10__Impl )
-            // InternalRoom.g:6478:2: rule__DataClass__Group__10__Impl
+            // InternalRoom.g:6676:1: ( rule__DataClass__Group__10__Impl )
+            // InternalRoom.g:6677:2: rule__DataClass__Group__10__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group__10__Impl();
@@ -19486,17 +20054,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__10__Impl"
-    // InternalRoom.g:6484:1: rule__DataClass__Group__10__Impl : ( '}' ) ;
+    // InternalRoom.g:6683:1: rule__DataClass__Group__10__Impl : ( '}' ) ;
     public final void rule__DataClass__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6488:1: ( ( '}' ) )
-            // InternalRoom.g:6489:1: ( '}' )
+            // InternalRoom.g:6687:1: ( ( '}' ) )
+            // InternalRoom.g:6688:1: ( '}' )
             {
-            // InternalRoom.g:6489:1: ( '}' )
-            // InternalRoom.g:6490:1: '}'
+            // InternalRoom.g:6688:1: ( '}' )
+            // InternalRoom.g:6689:1: '}'
             {
              before(grammarAccess.getDataClassAccess().getRightCurlyBracketKeyword_10()); 
             match(input,45,FOLLOW_2); 
@@ -19523,14 +20091,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_3__0"
-    // InternalRoom.g:6525:1: rule__DataClass__Group_3__0 : rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1 ;
+    // InternalRoom.g:6724:1: rule__DataClass__Group_3__0 : rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1 ;
     public final void rule__DataClass__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6529:1: ( rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1 )
-            // InternalRoom.g:6530:2: rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1
+            // InternalRoom.g:6728:1: ( rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1 )
+            // InternalRoom.g:6729:2: rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1
             {
             pushFollow(FOLLOW_3);
             rule__DataClass__Group_3__0__Impl();
@@ -19561,17 +20129,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_3__0__Impl"
-    // InternalRoom.g:6537:1: rule__DataClass__Group_3__0__Impl : ( 'extends' ) ;
+    // InternalRoom.g:6736:1: rule__DataClass__Group_3__0__Impl : ( 'extends' ) ;
     public final void rule__DataClass__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6541:1: ( ( 'extends' ) )
-            // InternalRoom.g:6542:1: ( 'extends' )
+            // InternalRoom.g:6740:1: ( ( 'extends' ) )
+            // InternalRoom.g:6741:1: ( 'extends' )
             {
-            // InternalRoom.g:6542:1: ( 'extends' )
-            // InternalRoom.g:6543:1: 'extends'
+            // InternalRoom.g:6741:1: ( 'extends' )
+            // InternalRoom.g:6742:1: 'extends'
             {
              before(grammarAccess.getDataClassAccess().getExtendsKeyword_3_0()); 
             match(input,57,FOLLOW_2); 
@@ -19598,14 +20166,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_3__1"
-    // InternalRoom.g:6556:1: rule__DataClass__Group_3__1 : rule__DataClass__Group_3__1__Impl ;
+    // InternalRoom.g:6755:1: rule__DataClass__Group_3__1 : rule__DataClass__Group_3__1__Impl ;
     public final void rule__DataClass__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6560:1: ( rule__DataClass__Group_3__1__Impl )
-            // InternalRoom.g:6561:2: rule__DataClass__Group_3__1__Impl
+            // InternalRoom.g:6759:1: ( rule__DataClass__Group_3__1__Impl )
+            // InternalRoom.g:6760:2: rule__DataClass__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_3__1__Impl();
@@ -19631,21 +20199,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_3__1__Impl"
-    // InternalRoom.g:6567:1: rule__DataClass__Group_3__1__Impl : ( ( rule__DataClass__BaseAssignment_3_1 ) ) ;
+    // InternalRoom.g:6766:1: rule__DataClass__Group_3__1__Impl : ( ( rule__DataClass__BaseAssignment_3_1 ) ) ;
     public final void rule__DataClass__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6571:1: ( ( ( rule__DataClass__BaseAssignment_3_1 ) ) )
-            // InternalRoom.g:6572:1: ( ( rule__DataClass__BaseAssignment_3_1 ) )
+            // InternalRoom.g:6770:1: ( ( ( rule__DataClass__BaseAssignment_3_1 ) ) )
+            // InternalRoom.g:6771:1: ( ( rule__DataClass__BaseAssignment_3_1 ) )
             {
-            // InternalRoom.g:6572:1: ( ( rule__DataClass__BaseAssignment_3_1 ) )
-            // InternalRoom.g:6573:1: ( rule__DataClass__BaseAssignment_3_1 )
+            // InternalRoom.g:6771:1: ( ( rule__DataClass__BaseAssignment_3_1 ) )
+            // InternalRoom.g:6772:1: ( rule__DataClass__BaseAssignment_3_1 )
             {
              before(grammarAccess.getDataClassAccess().getBaseAssignment_3_1()); 
-            // InternalRoom.g:6574:1: ( rule__DataClass__BaseAssignment_3_1 )
-            // InternalRoom.g:6574:2: rule__DataClass__BaseAssignment_3_1
+            // InternalRoom.g:6773:1: ( rule__DataClass__BaseAssignment_3_1 )
+            // InternalRoom.g:6773:2: rule__DataClass__BaseAssignment_3_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__BaseAssignment_3_1();
@@ -19678,14 +20246,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_6__0"
-    // InternalRoom.g:6588:1: rule__DataClass__Group_6__0 : rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1 ;
+    // InternalRoom.g:6787:1: rule__DataClass__Group_6__0 : rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1 ;
     public final void rule__DataClass__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6592:1: ( rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1 )
-            // InternalRoom.g:6593:2: rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1
+            // InternalRoom.g:6791:1: ( rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1 )
+            // InternalRoom.g:6792:2: rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_6__0__Impl();
@@ -19716,17 +20284,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_6__0__Impl"
-    // InternalRoom.g:6600:1: rule__DataClass__Group_6__0__Impl : ( 'usercode1' ) ;
+    // InternalRoom.g:6799:1: rule__DataClass__Group_6__0__Impl : ( 'usercode1' ) ;
     public final void rule__DataClass__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6604:1: ( ( 'usercode1' ) )
-            // InternalRoom.g:6605:1: ( 'usercode1' )
+            // InternalRoom.g:6803:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:6804:1: ( 'usercode1' )
             {
-            // InternalRoom.g:6605:1: ( 'usercode1' )
-            // InternalRoom.g:6606:1: 'usercode1'
+            // InternalRoom.g:6804:1: ( 'usercode1' )
+            // InternalRoom.g:6805:1: 'usercode1'
             {
              before(grammarAccess.getDataClassAccess().getUsercode1Keyword_6_0()); 
             match(input,58,FOLLOW_2); 
@@ -19753,14 +20321,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_6__1"
-    // InternalRoom.g:6619:1: rule__DataClass__Group_6__1 : rule__DataClass__Group_6__1__Impl ;
+    // InternalRoom.g:6818:1: rule__DataClass__Group_6__1 : rule__DataClass__Group_6__1__Impl ;
     public final void rule__DataClass__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6623:1: ( rule__DataClass__Group_6__1__Impl )
-            // InternalRoom.g:6624:2: rule__DataClass__Group_6__1__Impl
+            // InternalRoom.g:6822:1: ( rule__DataClass__Group_6__1__Impl )
+            // InternalRoom.g:6823:2: rule__DataClass__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_6__1__Impl();
@@ -19786,21 +20354,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_6__1__Impl"
-    // InternalRoom.g:6630:1: rule__DataClass__Group_6__1__Impl : ( ( rule__DataClass__UserCode1Assignment_6_1 ) ) ;
+    // InternalRoom.g:6829:1: rule__DataClass__Group_6__1__Impl : ( ( rule__DataClass__UserCode1Assignment_6_1 ) ) ;
     public final void rule__DataClass__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6634:1: ( ( ( rule__DataClass__UserCode1Assignment_6_1 ) ) )
-            // InternalRoom.g:6635:1: ( ( rule__DataClass__UserCode1Assignment_6_1 ) )
+            // InternalRoom.g:6833:1: ( ( ( rule__DataClass__UserCode1Assignment_6_1 ) ) )
+            // InternalRoom.g:6834:1: ( ( rule__DataClass__UserCode1Assignment_6_1 ) )
             {
-            // InternalRoom.g:6635:1: ( ( rule__DataClass__UserCode1Assignment_6_1 ) )
-            // InternalRoom.g:6636:1: ( rule__DataClass__UserCode1Assignment_6_1 )
+            // InternalRoom.g:6834:1: ( ( rule__DataClass__UserCode1Assignment_6_1 ) )
+            // InternalRoom.g:6835:1: ( rule__DataClass__UserCode1Assignment_6_1 )
             {
              before(grammarAccess.getDataClassAccess().getUserCode1Assignment_6_1()); 
-            // InternalRoom.g:6637:1: ( rule__DataClass__UserCode1Assignment_6_1 )
-            // InternalRoom.g:6637:2: rule__DataClass__UserCode1Assignment_6_1
+            // InternalRoom.g:6836:1: ( rule__DataClass__UserCode1Assignment_6_1 )
+            // InternalRoom.g:6836:2: rule__DataClass__UserCode1Assignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode1Assignment_6_1();
@@ -19833,14 +20401,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_7__0"
-    // InternalRoom.g:6651:1: rule__DataClass__Group_7__0 : rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1 ;
+    // InternalRoom.g:6850:1: rule__DataClass__Group_7__0 : rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1 ;
     public final void rule__DataClass__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6655:1: ( rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1 )
-            // InternalRoom.g:6656:2: rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1
+            // InternalRoom.g:6854:1: ( rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1 )
+            // InternalRoom.g:6855:2: rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_7__0__Impl();
@@ -19871,17 +20439,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_7__0__Impl"
-    // InternalRoom.g:6663:1: rule__DataClass__Group_7__0__Impl : ( 'usercode2' ) ;
+    // InternalRoom.g:6862:1: rule__DataClass__Group_7__0__Impl : ( 'usercode2' ) ;
     public final void rule__DataClass__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6667:1: ( ( 'usercode2' ) )
-            // InternalRoom.g:6668:1: ( 'usercode2' )
+            // InternalRoom.g:6866:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:6867:1: ( 'usercode2' )
             {
-            // InternalRoom.g:6668:1: ( 'usercode2' )
-            // InternalRoom.g:6669:1: 'usercode2'
+            // InternalRoom.g:6867:1: ( 'usercode2' )
+            // InternalRoom.g:6868:1: 'usercode2'
             {
              before(grammarAccess.getDataClassAccess().getUsercode2Keyword_7_0()); 
             match(input,59,FOLLOW_2); 
@@ -19908,14 +20476,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_7__1"
-    // InternalRoom.g:6682:1: rule__DataClass__Group_7__1 : rule__DataClass__Group_7__1__Impl ;
+    // InternalRoom.g:6881:1: rule__DataClass__Group_7__1 : rule__DataClass__Group_7__1__Impl ;
     public final void rule__DataClass__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6686:1: ( rule__DataClass__Group_7__1__Impl )
-            // InternalRoom.g:6687:2: rule__DataClass__Group_7__1__Impl
+            // InternalRoom.g:6885:1: ( rule__DataClass__Group_7__1__Impl )
+            // InternalRoom.g:6886:2: rule__DataClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_7__1__Impl();
@@ -19941,21 +20509,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_7__1__Impl"
-    // InternalRoom.g:6693:1: rule__DataClass__Group_7__1__Impl : ( ( rule__DataClass__UserCode2Assignment_7_1 ) ) ;
+    // InternalRoom.g:6892:1: rule__DataClass__Group_7__1__Impl : ( ( rule__DataClass__UserCode2Assignment_7_1 ) ) ;
     public final void rule__DataClass__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6697:1: ( ( ( rule__DataClass__UserCode2Assignment_7_1 ) ) )
-            // InternalRoom.g:6698:1: ( ( rule__DataClass__UserCode2Assignment_7_1 ) )
+            // InternalRoom.g:6896:1: ( ( ( rule__DataClass__UserCode2Assignment_7_1 ) ) )
+            // InternalRoom.g:6897:1: ( ( rule__DataClass__UserCode2Assignment_7_1 ) )
             {
-            // InternalRoom.g:6698:1: ( ( rule__DataClass__UserCode2Assignment_7_1 ) )
-            // InternalRoom.g:6699:1: ( rule__DataClass__UserCode2Assignment_7_1 )
+            // InternalRoom.g:6897:1: ( ( rule__DataClass__UserCode2Assignment_7_1 ) )
+            // InternalRoom.g:6898:1: ( rule__DataClass__UserCode2Assignment_7_1 )
             {
              before(grammarAccess.getDataClassAccess().getUserCode2Assignment_7_1()); 
-            // InternalRoom.g:6700:1: ( rule__DataClass__UserCode2Assignment_7_1 )
-            // InternalRoom.g:6700:2: rule__DataClass__UserCode2Assignment_7_1
+            // InternalRoom.g:6899:1: ( rule__DataClass__UserCode2Assignment_7_1 )
+            // InternalRoom.g:6899:2: rule__DataClass__UserCode2Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode2Assignment_7_1();
@@ -19988,14 +20556,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_8__0"
-    // InternalRoom.g:6714:1: rule__DataClass__Group_8__0 : rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1 ;
+    // InternalRoom.g:6913:1: rule__DataClass__Group_8__0 : rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1 ;
     public final void rule__DataClass__Group_8__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6718:1: ( rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1 )
-            // InternalRoom.g:6719:2: rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1
+            // InternalRoom.g:6917:1: ( rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1 )
+            // InternalRoom.g:6918:2: rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_8__0__Impl();
@@ -20026,17 +20594,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_8__0__Impl"
-    // InternalRoom.g:6726:1: rule__DataClass__Group_8__0__Impl : ( 'usercode3' ) ;
+    // InternalRoom.g:6925:1: rule__DataClass__Group_8__0__Impl : ( 'usercode3' ) ;
     public final void rule__DataClass__Group_8__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6730:1: ( ( 'usercode3' ) )
-            // InternalRoom.g:6731:1: ( 'usercode3' )
+            // InternalRoom.g:6929:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:6930:1: ( 'usercode3' )
             {
-            // InternalRoom.g:6731:1: ( 'usercode3' )
-            // InternalRoom.g:6732:1: 'usercode3'
+            // InternalRoom.g:6930:1: ( 'usercode3' )
+            // InternalRoom.g:6931:1: 'usercode3'
             {
              before(grammarAccess.getDataClassAccess().getUsercode3Keyword_8_0()); 
             match(input,60,FOLLOW_2); 
@@ -20063,14 +20631,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_8__1"
-    // InternalRoom.g:6745:1: rule__DataClass__Group_8__1 : rule__DataClass__Group_8__1__Impl ;
+    // InternalRoom.g:6944:1: rule__DataClass__Group_8__1 : rule__DataClass__Group_8__1__Impl ;
     public final void rule__DataClass__Group_8__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6749:1: ( rule__DataClass__Group_8__1__Impl )
-            // InternalRoom.g:6750:2: rule__DataClass__Group_8__1__Impl
+            // InternalRoom.g:6948:1: ( rule__DataClass__Group_8__1__Impl )
+            // InternalRoom.g:6949:2: rule__DataClass__Group_8__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_8__1__Impl();
@@ -20096,21 +20664,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group_8__1__Impl"
-    // InternalRoom.g:6756:1: rule__DataClass__Group_8__1__Impl : ( ( rule__DataClass__UserCode3Assignment_8_1 ) ) ;
+    // InternalRoom.g:6955:1: rule__DataClass__Group_8__1__Impl : ( ( rule__DataClass__UserCode3Assignment_8_1 ) ) ;
     public final void rule__DataClass__Group_8__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6760:1: ( ( ( rule__DataClass__UserCode3Assignment_8_1 ) ) )
-            // InternalRoom.g:6761:1: ( ( rule__DataClass__UserCode3Assignment_8_1 ) )
+            // InternalRoom.g:6959:1: ( ( ( rule__DataClass__UserCode3Assignment_8_1 ) ) )
+            // InternalRoom.g:6960:1: ( ( rule__DataClass__UserCode3Assignment_8_1 ) )
             {
-            // InternalRoom.g:6761:1: ( ( rule__DataClass__UserCode3Assignment_8_1 ) )
-            // InternalRoom.g:6762:1: ( rule__DataClass__UserCode3Assignment_8_1 )
+            // InternalRoom.g:6960:1: ( ( rule__DataClass__UserCode3Assignment_8_1 ) )
+            // InternalRoom.g:6961:1: ( rule__DataClass__UserCode3Assignment_8_1 )
             {
              before(grammarAccess.getDataClassAccess().getUserCode3Assignment_8_1()); 
-            // InternalRoom.g:6763:1: ( rule__DataClass__UserCode3Assignment_8_1 )
-            // InternalRoom.g:6763:2: rule__DataClass__UserCode3Assignment_8_1
+            // InternalRoom.g:6962:1: ( rule__DataClass__UserCode3Assignment_8_1 )
+            // InternalRoom.g:6962:2: rule__DataClass__UserCode3Assignment_8_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode3Assignment_8_1();
@@ -20143,14 +20711,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__0"
-    // InternalRoom.g:6777:1: rule__Attribute__Group__0 : rule__Attribute__Group__0__Impl rule__Attribute__Group__1 ;
+    // InternalRoom.g:6976:1: rule__Attribute__Group__0 : rule__Attribute__Group__0__Impl rule__Attribute__Group__1 ;
     public final void rule__Attribute__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6781:1: ( rule__Attribute__Group__0__Impl rule__Attribute__Group__1 )
-            // InternalRoom.g:6782:2: rule__Attribute__Group__0__Impl rule__Attribute__Group__1
+            // InternalRoom.g:6980:1: ( rule__Attribute__Group__0__Impl rule__Attribute__Group__1 )
+            // InternalRoom.g:6981:2: rule__Attribute__Group__0__Impl rule__Attribute__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Attribute__Group__0__Impl();
@@ -20181,17 +20749,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__0__Impl"
-    // InternalRoom.g:6789:1: rule__Attribute__Group__0__Impl : ( 'Attribute' ) ;
+    // InternalRoom.g:6988:1: rule__Attribute__Group__0__Impl : ( 'Attribute' ) ;
     public final void rule__Attribute__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6793:1: ( ( 'Attribute' ) )
-            // InternalRoom.g:6794:1: ( 'Attribute' )
+            // InternalRoom.g:6992:1: ( ( 'Attribute' ) )
+            // InternalRoom.g:6993:1: ( 'Attribute' )
             {
-            // InternalRoom.g:6794:1: ( 'Attribute' )
-            // InternalRoom.g:6795:1: 'Attribute'
+            // InternalRoom.g:6993:1: ( 'Attribute' )
+            // InternalRoom.g:6994:1: 'Attribute'
             {
              before(grammarAccess.getAttributeAccess().getAttributeKeyword_0()); 
             match(input,61,FOLLOW_2); 
@@ -20218,14 +20786,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__1"
-    // InternalRoom.g:6808:1: rule__Attribute__Group__1 : rule__Attribute__Group__1__Impl rule__Attribute__Group__2 ;
+    // InternalRoom.g:7007:1: rule__Attribute__Group__1 : rule__Attribute__Group__1__Impl rule__Attribute__Group__2 ;
     public final void rule__Attribute__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6812:1: ( rule__Attribute__Group__1__Impl rule__Attribute__Group__2 )
-            // InternalRoom.g:6813:2: rule__Attribute__Group__1__Impl rule__Attribute__Group__2
+            // InternalRoom.g:7011:1: ( rule__Attribute__Group__1__Impl rule__Attribute__Group__2 )
+            // InternalRoom.g:7012:2: rule__Attribute__Group__1__Impl rule__Attribute__Group__2
             {
             pushFollow(FOLLOW_28);
             rule__Attribute__Group__1__Impl();
@@ -20256,21 +20824,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__1__Impl"
-    // InternalRoom.g:6820:1: rule__Attribute__Group__1__Impl : ( ( rule__Attribute__NameAssignment_1 ) ) ;
+    // InternalRoom.g:7019:1: rule__Attribute__Group__1__Impl : ( ( rule__Attribute__NameAssignment_1 ) ) ;
     public final void rule__Attribute__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6824:1: ( ( ( rule__Attribute__NameAssignment_1 ) ) )
-            // InternalRoom.g:6825:1: ( ( rule__Attribute__NameAssignment_1 ) )
+            // InternalRoom.g:7023:1: ( ( ( rule__Attribute__NameAssignment_1 ) ) )
+            // InternalRoom.g:7024:1: ( ( rule__Attribute__NameAssignment_1 ) )
             {
-            // InternalRoom.g:6825:1: ( ( rule__Attribute__NameAssignment_1 ) )
-            // InternalRoom.g:6826:1: ( rule__Attribute__NameAssignment_1 )
+            // InternalRoom.g:7024:1: ( ( rule__Attribute__NameAssignment_1 ) )
+            // InternalRoom.g:7025:1: ( rule__Attribute__NameAssignment_1 )
             {
              before(grammarAccess.getAttributeAccess().getNameAssignment_1()); 
-            // InternalRoom.g:6827:1: ( rule__Attribute__NameAssignment_1 )
-            // InternalRoom.g:6827:2: rule__Attribute__NameAssignment_1
+            // InternalRoom.g:7026:1: ( rule__Attribute__NameAssignment_1 )
+            // InternalRoom.g:7026:2: rule__Attribute__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__NameAssignment_1();
@@ -20303,14 +20871,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__2"
-    // InternalRoom.g:6837:1: rule__Attribute__Group__2 : rule__Attribute__Group__2__Impl rule__Attribute__Group__3 ;
+    // InternalRoom.g:7036:1: rule__Attribute__Group__2 : rule__Attribute__Group__2__Impl rule__Attribute__Group__3 ;
     public final void rule__Attribute__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6841:1: ( rule__Attribute__Group__2__Impl rule__Attribute__Group__3 )
-            // InternalRoom.g:6842:2: rule__Attribute__Group__2__Impl rule__Attribute__Group__3
+            // InternalRoom.g:7040:1: ( rule__Attribute__Group__2__Impl rule__Attribute__Group__3 )
+            // InternalRoom.g:7041:2: rule__Attribute__Group__2__Impl rule__Attribute__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__Attribute__Group__2__Impl();
@@ -20341,29 +20909,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__2__Impl"
-    // InternalRoom.g:6849:1: rule__Attribute__Group__2__Impl : ( ( rule__Attribute__Group_2__0 )? ) ;
+    // InternalRoom.g:7048:1: rule__Attribute__Group__2__Impl : ( ( rule__Attribute__Group_2__0 )? ) ;
     public final void rule__Attribute__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6853:1: ( ( ( rule__Attribute__Group_2__0 )? ) )
-            // InternalRoom.g:6854:1: ( ( rule__Attribute__Group_2__0 )? )
+            // InternalRoom.g:7052:1: ( ( ( rule__Attribute__Group_2__0 )? ) )
+            // InternalRoom.g:7053:1: ( ( rule__Attribute__Group_2__0 )? )
             {
-            // InternalRoom.g:6854:1: ( ( rule__Attribute__Group_2__0 )? )
-            // InternalRoom.g:6855:1: ( rule__Attribute__Group_2__0 )?
+            // InternalRoom.g:7053:1: ( ( rule__Attribute__Group_2__0 )? )
+            // InternalRoom.g:7054:1: ( rule__Attribute__Group_2__0 )?
             {
              before(grammarAccess.getAttributeAccess().getGroup_2()); 
-            // InternalRoom.g:6856:1: ( rule__Attribute__Group_2__0 )?
-            int alt75=2;
-            int LA75_0 = input.LA(1);
+            // InternalRoom.g:7055:1: ( rule__Attribute__Group_2__0 )?
+            int alt77=2;
+            int LA77_0 = input.LA(1);
 
-            if ( (LA75_0==62) ) {
-                alt75=1;
+            if ( (LA77_0==62) ) {
+                alt77=1;
             }
-            switch (alt75) {
+            switch (alt77) {
                 case 1 :
-                    // InternalRoom.g:6856:2: rule__Attribute__Group_2__0
+                    // InternalRoom.g:7055:2: rule__Attribute__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__Group_2__0();
@@ -20399,14 +20967,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__3"
-    // InternalRoom.g:6866:1: rule__Attribute__Group__3 : rule__Attribute__Group__3__Impl rule__Attribute__Group__4 ;
+    // InternalRoom.g:7065:1: rule__Attribute__Group__3 : rule__Attribute__Group__3__Impl rule__Attribute__Group__4 ;
     public final void rule__Attribute__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6870:1: ( rule__Attribute__Group__3__Impl rule__Attribute__Group__4 )
-            // InternalRoom.g:6871:2: rule__Attribute__Group__3__Impl rule__Attribute__Group__4
+            // InternalRoom.g:7069:1: ( rule__Attribute__Group__3__Impl rule__Attribute__Group__4 )
+            // InternalRoom.g:7070:2: rule__Attribute__Group__3__Impl rule__Attribute__Group__4
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__3__Impl();
@@ -20437,17 +21005,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__3__Impl"
-    // InternalRoom.g:6878:1: rule__Attribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:7077:1: rule__Attribute__Group__3__Impl : ( ':' ) ;
     public final void rule__Attribute__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6882:1: ( ( ':' ) )
-            // InternalRoom.g:6883:1: ( ':' )
+            // InternalRoom.g:7081:1: ( ( ':' ) )
+            // InternalRoom.g:7082:1: ( ':' )
             {
-            // InternalRoom.g:6883:1: ( ':' )
-            // InternalRoom.g:6884:1: ':'
+            // InternalRoom.g:7082:1: ( ':' )
+            // InternalRoom.g:7083:1: ':'
             {
              before(grammarAccess.getAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -20474,14 +21042,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__4"
-    // InternalRoom.g:6897:1: rule__Attribute__Group__4 : rule__Attribute__Group__4__Impl rule__Attribute__Group__5 ;
+    // InternalRoom.g:7096:1: rule__Attribute__Group__4 : rule__Attribute__Group__4__Impl rule__Attribute__Group__5 ;
     public final void rule__Attribute__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6901:1: ( rule__Attribute__Group__4__Impl rule__Attribute__Group__5 )
-            // InternalRoom.g:6902:2: rule__Attribute__Group__4__Impl rule__Attribute__Group__5
+            // InternalRoom.g:7100:1: ( rule__Attribute__Group__4__Impl rule__Attribute__Group__5 )
+            // InternalRoom.g:7101:2: rule__Attribute__Group__4__Impl rule__Attribute__Group__5
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__4__Impl();
@@ -20512,29 +21080,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__4__Impl"
-    // InternalRoom.g:6909:1: rule__Attribute__Group__4__Impl : ( ( rule__Attribute__TypeAssignment_4 )? ) ;
+    // InternalRoom.g:7108:1: rule__Attribute__Group__4__Impl : ( ( rule__Attribute__TypeAssignment_4 )? ) ;
     public final void rule__Attribute__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6913:1: ( ( ( rule__Attribute__TypeAssignment_4 )? ) )
-            // InternalRoom.g:6914:1: ( ( rule__Attribute__TypeAssignment_4 )? )
+            // InternalRoom.g:7112:1: ( ( ( rule__Attribute__TypeAssignment_4 )? ) )
+            // InternalRoom.g:7113:1: ( ( rule__Attribute__TypeAssignment_4 )? )
             {
-            // InternalRoom.g:6914:1: ( ( rule__Attribute__TypeAssignment_4 )? )
-            // InternalRoom.g:6915:1: ( rule__Attribute__TypeAssignment_4 )?
+            // InternalRoom.g:7113:1: ( ( rule__Attribute__TypeAssignment_4 )? )
+            // InternalRoom.g:7114:1: ( rule__Attribute__TypeAssignment_4 )?
             {
              before(grammarAccess.getAttributeAccess().getTypeAssignment_4()); 
-            // InternalRoom.g:6916:1: ( rule__Attribute__TypeAssignment_4 )?
-            int alt76=2;
-            int LA76_0 = input.LA(1);
+            // InternalRoom.g:7115:1: ( rule__Attribute__TypeAssignment_4 )?
+            int alt78=2;
+            int LA78_0 = input.LA(1);
 
-            if ( (LA76_0==RULE_ID) ) {
-                alt76=1;
+            if ( (LA78_0==RULE_ID) ) {
+                alt78=1;
             }
-            switch (alt76) {
+            switch (alt78) {
                 case 1 :
-                    // InternalRoom.g:6916:2: rule__Attribute__TypeAssignment_4
+                    // InternalRoom.g:7115:2: rule__Attribute__TypeAssignment_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__TypeAssignment_4();
@@ -20570,14 +21138,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__5"
-    // InternalRoom.g:6926:1: rule__Attribute__Group__5 : rule__Attribute__Group__5__Impl rule__Attribute__Group__6 ;
+    // InternalRoom.g:7125:1: rule__Attribute__Group__5 : rule__Attribute__Group__5__Impl rule__Attribute__Group__6 ;
     public final void rule__Attribute__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6930:1: ( rule__Attribute__Group__5__Impl rule__Attribute__Group__6 )
-            // InternalRoom.g:6931:2: rule__Attribute__Group__5__Impl rule__Attribute__Group__6
+            // InternalRoom.g:7129:1: ( rule__Attribute__Group__5__Impl rule__Attribute__Group__6 )
+            // InternalRoom.g:7130:2: rule__Attribute__Group__5__Impl rule__Attribute__Group__6
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__5__Impl();
@@ -20608,29 +21176,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__5__Impl"
-    // InternalRoom.g:6938:1: rule__Attribute__Group__5__Impl : ( ( rule__Attribute__Group_5__0 )? ) ;
+    // InternalRoom.g:7137:1: rule__Attribute__Group__5__Impl : ( ( rule__Attribute__Group_5__0 )? ) ;
     public final void rule__Attribute__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6942:1: ( ( ( rule__Attribute__Group_5__0 )? ) )
-            // InternalRoom.g:6943:1: ( ( rule__Attribute__Group_5__0 )? )
+            // InternalRoom.g:7141:1: ( ( ( rule__Attribute__Group_5__0 )? ) )
+            // InternalRoom.g:7142:1: ( ( rule__Attribute__Group_5__0 )? )
             {
-            // InternalRoom.g:6943:1: ( ( rule__Attribute__Group_5__0 )? )
-            // InternalRoom.g:6944:1: ( rule__Attribute__Group_5__0 )?
+            // InternalRoom.g:7142:1: ( ( rule__Attribute__Group_5__0 )? )
+            // InternalRoom.g:7143:1: ( rule__Attribute__Group_5__0 )?
             {
              before(grammarAccess.getAttributeAccess().getGroup_5()); 
-            // InternalRoom.g:6945:1: ( rule__Attribute__Group_5__0 )?
-            int alt77=2;
-            int LA77_0 = input.LA(1);
+            // InternalRoom.g:7144:1: ( rule__Attribute__Group_5__0 )?
+            int alt79=2;
+            int LA79_0 = input.LA(1);
 
-            if ( (LA77_0==55) ) {
-                alt77=1;
+            if ( (LA79_0==55) ) {
+                alt79=1;
             }
-            switch (alt77) {
+            switch (alt79) {
                 case 1 :
-                    // InternalRoom.g:6945:2: rule__Attribute__Group_5__0
+                    // InternalRoom.g:7144:2: rule__Attribute__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__Group_5__0();
@@ -20666,14 +21234,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__6"
-    // InternalRoom.g:6955:1: rule__Attribute__Group__6 : rule__Attribute__Group__6__Impl ;
+    // InternalRoom.g:7154:1: rule__Attribute__Group__6 : rule__Attribute__Group__6__Impl ;
     public final void rule__Attribute__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6959:1: ( rule__Attribute__Group__6__Impl )
-            // InternalRoom.g:6960:2: rule__Attribute__Group__6__Impl
+            // InternalRoom.g:7158:1: ( rule__Attribute__Group__6__Impl )
+            // InternalRoom.g:7159:2: rule__Attribute__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group__6__Impl();
@@ -20699,29 +21267,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__6__Impl"
-    // InternalRoom.g:6966:1: rule__Attribute__Group__6__Impl : ( ( rule__Attribute__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:7165:1: rule__Attribute__Group__6__Impl : ( ( rule__Attribute__DocuAssignment_6 )? ) ;
     public final void rule__Attribute__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:6970:1: ( ( ( rule__Attribute__DocuAssignment_6 )? ) )
-            // InternalRoom.g:6971:1: ( ( rule__Attribute__DocuAssignment_6 )? )
+            // InternalRoom.g:7169:1: ( ( ( rule__Attribute__DocuAssignment_6 )? ) )
+            // InternalRoom.g:7170:1: ( ( rule__Attribute__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:6971:1: ( ( rule__Attribute__DocuAssignment_6 )? )
-            // InternalRoom.g:6972:1: ( rule__Attribute__DocuAssignment_6 )?
+            // InternalRoom.g:7170:1: ( ( rule__Attribute__DocuAssignment_6 )? )
+            // InternalRoom.g:7171:1: ( rule__Attribute__DocuAssignment_6 )?
             {
              before(grammarAccess.getAttributeAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:6973:1: ( rule__Attribute__DocuAssignment_6 )?
-            int alt78=2;
-            int LA78_0 = input.LA(1);
+            // InternalRoom.g:7172:1: ( rule__Attribute__DocuAssignment_6 )?
+            int alt80=2;
+            int LA80_0 = input.LA(1);
 
-            if ( (LA78_0==62) ) {
-                alt78=1;
+            if ( (LA80_0==62) ) {
+                alt80=1;
             }
-            switch (alt78) {
+            switch (alt80) {
                 case 1 :
-                    // InternalRoom.g:6973:2: rule__Attribute__DocuAssignment_6
+                    // InternalRoom.g:7172:2: rule__Attribute__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__DocuAssignment_6();
@@ -20757,14 +21325,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__0"
-    // InternalRoom.g:6997:1: rule__Attribute__Group_2__0 : rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1 ;
+    // InternalRoom.g:7196:1: rule__Attribute__Group_2__0 : rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1 ;
     public final void rule__Attribute__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7001:1: ( rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1 )
-            // InternalRoom.g:7002:2: rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1
+            // InternalRoom.g:7200:1: ( rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1 )
+            // InternalRoom.g:7201:2: rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1
             {
             pushFollow(FOLLOW_30);
             rule__Attribute__Group_2__0__Impl();
@@ -20795,17 +21363,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__0__Impl"
-    // InternalRoom.g:7009:1: rule__Attribute__Group_2__0__Impl : ( '[' ) ;
+    // InternalRoom.g:7208:1: rule__Attribute__Group_2__0__Impl : ( '[' ) ;
     public final void rule__Attribute__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7013:1: ( ( '[' ) )
-            // InternalRoom.g:7014:1: ( '[' )
+            // InternalRoom.g:7212:1: ( ( '[' ) )
+            // InternalRoom.g:7213:1: ( '[' )
             {
-            // InternalRoom.g:7014:1: ( '[' )
-            // InternalRoom.g:7015:1: '['
+            // InternalRoom.g:7213:1: ( '[' )
+            // InternalRoom.g:7214:1: '['
             {
              before(grammarAccess.getAttributeAccess().getLeftSquareBracketKeyword_2_0()); 
             match(input,62,FOLLOW_2); 
@@ -20832,14 +21400,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__1"
-    // InternalRoom.g:7028:1: rule__Attribute__Group_2__1 : rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2 ;
+    // InternalRoom.g:7227:1: rule__Attribute__Group_2__1 : rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2 ;
     public final void rule__Attribute__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7032:1: ( rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2 )
-            // InternalRoom.g:7033:2: rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2
+            // InternalRoom.g:7231:1: ( rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2 )
+            // InternalRoom.g:7232:2: rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2
             {
             pushFollow(FOLLOW_31);
             rule__Attribute__Group_2__1__Impl();
@@ -20870,21 +21438,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__1__Impl"
-    // InternalRoom.g:7040:1: rule__Attribute__Group_2__1__Impl : ( ( rule__Attribute__SizeAssignment_2_1 ) ) ;
+    // InternalRoom.g:7239:1: rule__Attribute__Group_2__1__Impl : ( ( rule__Attribute__SizeAssignment_2_1 ) ) ;
     public final void rule__Attribute__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7044:1: ( ( ( rule__Attribute__SizeAssignment_2_1 ) ) )
-            // InternalRoom.g:7045:1: ( ( rule__Attribute__SizeAssignment_2_1 ) )
+            // InternalRoom.g:7243:1: ( ( ( rule__Attribute__SizeAssignment_2_1 ) ) )
+            // InternalRoom.g:7244:1: ( ( rule__Attribute__SizeAssignment_2_1 ) )
             {
-            // InternalRoom.g:7045:1: ( ( rule__Attribute__SizeAssignment_2_1 ) )
-            // InternalRoom.g:7046:1: ( rule__Attribute__SizeAssignment_2_1 )
+            // InternalRoom.g:7244:1: ( ( rule__Attribute__SizeAssignment_2_1 ) )
+            // InternalRoom.g:7245:1: ( rule__Attribute__SizeAssignment_2_1 )
             {
              before(grammarAccess.getAttributeAccess().getSizeAssignment_2_1()); 
-            // InternalRoom.g:7047:1: ( rule__Attribute__SizeAssignment_2_1 )
-            // InternalRoom.g:7047:2: rule__Attribute__SizeAssignment_2_1
+            // InternalRoom.g:7246:1: ( rule__Attribute__SizeAssignment_2_1 )
+            // InternalRoom.g:7246:2: rule__Attribute__SizeAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__SizeAssignment_2_1();
@@ -20917,14 +21485,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__2"
-    // InternalRoom.g:7057:1: rule__Attribute__Group_2__2 : rule__Attribute__Group_2__2__Impl ;
+    // InternalRoom.g:7256:1: rule__Attribute__Group_2__2 : rule__Attribute__Group_2__2__Impl ;
     public final void rule__Attribute__Group_2__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7061:1: ( rule__Attribute__Group_2__2__Impl )
-            // InternalRoom.g:7062:2: rule__Attribute__Group_2__2__Impl
+            // InternalRoom.g:7260:1: ( rule__Attribute__Group_2__2__Impl )
+            // InternalRoom.g:7261:2: rule__Attribute__Group_2__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group_2__2__Impl();
@@ -20950,17 +21518,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_2__2__Impl"
-    // InternalRoom.g:7068:1: rule__Attribute__Group_2__2__Impl : ( ']' ) ;
+    // InternalRoom.g:7267:1: rule__Attribute__Group_2__2__Impl : ( ']' ) ;
     public final void rule__Attribute__Group_2__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7072:1: ( ( ']' ) )
-            // InternalRoom.g:7073:1: ( ']' )
+            // InternalRoom.g:7271:1: ( ( ']' ) )
+            // InternalRoom.g:7272:1: ( ']' )
             {
-            // InternalRoom.g:7073:1: ( ']' )
-            // InternalRoom.g:7074:1: ']'
+            // InternalRoom.g:7272:1: ( ']' )
+            // InternalRoom.g:7273:1: ']'
             {
              before(grammarAccess.getAttributeAccess().getRightSquareBracketKeyword_2_2()); 
             match(input,63,FOLLOW_2); 
@@ -20987,14 +21555,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_5__0"
-    // InternalRoom.g:7093:1: rule__Attribute__Group_5__0 : rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1 ;
+    // InternalRoom.g:7292:1: rule__Attribute__Group_5__0 : rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1 ;
     public final void rule__Attribute__Group_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7097:1: ( rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1 )
-            // InternalRoom.g:7098:2: rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1
+            // InternalRoom.g:7296:1: ( rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1 )
+            // InternalRoom.g:7297:2: rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1
             {
             pushFollow(FOLLOW_12);
             rule__Attribute__Group_5__0__Impl();
@@ -21025,17 +21593,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_5__0__Impl"
-    // InternalRoom.g:7105:1: rule__Attribute__Group_5__0__Impl : ( '=' ) ;
+    // InternalRoom.g:7304:1: rule__Attribute__Group_5__0__Impl : ( '=' ) ;
     public final void rule__Attribute__Group_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7109:1: ( ( '=' ) )
-            // InternalRoom.g:7110:1: ( '=' )
+            // InternalRoom.g:7308:1: ( ( '=' ) )
+            // InternalRoom.g:7309:1: ( '=' )
             {
-            // InternalRoom.g:7110:1: ( '=' )
-            // InternalRoom.g:7111:1: '='
+            // InternalRoom.g:7309:1: ( '=' )
+            // InternalRoom.g:7310:1: '='
             {
              before(grammarAccess.getAttributeAccess().getEqualsSignKeyword_5_0()); 
             match(input,55,FOLLOW_2); 
@@ -21062,14 +21630,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_5__1"
-    // InternalRoom.g:7124:1: rule__Attribute__Group_5__1 : rule__Attribute__Group_5__1__Impl ;
+    // InternalRoom.g:7323:1: rule__Attribute__Group_5__1 : rule__Attribute__Group_5__1__Impl ;
     public final void rule__Attribute__Group_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7128:1: ( rule__Attribute__Group_5__1__Impl )
-            // InternalRoom.g:7129:2: rule__Attribute__Group_5__1__Impl
+            // InternalRoom.g:7327:1: ( rule__Attribute__Group_5__1__Impl )
+            // InternalRoom.g:7328:2: rule__Attribute__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group_5__1__Impl();
@@ -21095,21 +21663,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group_5__1__Impl"
-    // InternalRoom.g:7135:1: rule__Attribute__Group_5__1__Impl : ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) ) ;
+    // InternalRoom.g:7334:1: rule__Attribute__Group_5__1__Impl : ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) ) ;
     public final void rule__Attribute__Group_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7139:1: ( ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) ) )
-            // InternalRoom.g:7140:1: ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) )
+            // InternalRoom.g:7338:1: ( ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) ) )
+            // InternalRoom.g:7339:1: ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) )
             {
-            // InternalRoom.g:7140:1: ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) )
-            // InternalRoom.g:7141:1: ( rule__Attribute__DefaultValueLiteralAssignment_5_1 )
+            // InternalRoom.g:7339:1: ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) )
+            // InternalRoom.g:7340:1: ( rule__Attribute__DefaultValueLiteralAssignment_5_1 )
             {
              before(grammarAccess.getAttributeAccess().getDefaultValueLiteralAssignment_5_1()); 
-            // InternalRoom.g:7142:1: ( rule__Attribute__DefaultValueLiteralAssignment_5_1 )
-            // InternalRoom.g:7142:2: rule__Attribute__DefaultValueLiteralAssignment_5_1
+            // InternalRoom.g:7341:1: ( rule__Attribute__DefaultValueLiteralAssignment_5_1 )
+            // InternalRoom.g:7341:2: rule__Attribute__DefaultValueLiteralAssignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__DefaultValueLiteralAssignment_5_1();
@@ -21142,14 +21710,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__0"
-    // InternalRoom.g:7156:1: rule__StandardOperation__Group__0 : rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1 ;
+    // InternalRoom.g:7355:1: rule__StandardOperation__Group__0 : rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1 ;
     public final void rule__StandardOperation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7160:1: ( rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1 )
-            // InternalRoom.g:7161:2: rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1
+            // InternalRoom.g:7359:1: ( rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1 )
+            // InternalRoom.g:7360:2: rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1
             {
             pushFollow(FOLLOW_32);
             rule__StandardOperation__Group__0__Impl();
@@ -21180,29 +21748,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__0__Impl"
-    // InternalRoom.g:7168:1: rule__StandardOperation__Group__0__Impl : ( ( rule__StandardOperation__OverrideAssignment_0 )? ) ;
+    // InternalRoom.g:7367:1: rule__StandardOperation__Group__0__Impl : ( ( rule__StandardOperation__OverrideAssignment_0 )? ) ;
     public final void rule__StandardOperation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7172:1: ( ( ( rule__StandardOperation__OverrideAssignment_0 )? ) )
-            // InternalRoom.g:7173:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
+            // InternalRoom.g:7371:1: ( ( ( rule__StandardOperation__OverrideAssignment_0 )? ) )
+            // InternalRoom.g:7372:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
             {
-            // InternalRoom.g:7173:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
-            // InternalRoom.g:7174:1: ( rule__StandardOperation__OverrideAssignment_0 )?
+            // InternalRoom.g:7372:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
+            // InternalRoom.g:7373:1: ( rule__StandardOperation__OverrideAssignment_0 )?
             {
              before(grammarAccess.getStandardOperationAccess().getOverrideAssignment_0()); 
-            // InternalRoom.g:7175:1: ( rule__StandardOperation__OverrideAssignment_0 )?
-            int alt79=2;
-            int LA79_0 = input.LA(1);
+            // InternalRoom.g:7374:1: ( rule__StandardOperation__OverrideAssignment_0 )?
+            int alt81=2;
+            int LA81_0 = input.LA(1);
 
-            if ( (LA79_0==128) ) {
-                alt79=1;
+            if ( (LA81_0==128) ) {
+                alt81=1;
             }
-            switch (alt79) {
+            switch (alt81) {
                 case 1 :
-                    // InternalRoom.g:7175:2: rule__StandardOperation__OverrideAssignment_0
+                    // InternalRoom.g:7374:2: rule__StandardOperation__OverrideAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__OverrideAssignment_0();
@@ -21238,14 +21806,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__1"
-    // InternalRoom.g:7185:1: rule__StandardOperation__Group__1 : rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2 ;
+    // InternalRoom.g:7384:1: rule__StandardOperation__Group__1 : rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2 ;
     public final void rule__StandardOperation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7189:1: ( rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2 )
-            // InternalRoom.g:7190:2: rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2
+            // InternalRoom.g:7388:1: ( rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2 )
+            // InternalRoom.g:7389:2: rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__StandardOperation__Group__1__Impl();
@@ -21276,17 +21844,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__1__Impl"
-    // InternalRoom.g:7197:1: rule__StandardOperation__Group__1__Impl : ( 'Operation' ) ;
+    // InternalRoom.g:7396:1: rule__StandardOperation__Group__1__Impl : ( 'Operation' ) ;
     public final void rule__StandardOperation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7201:1: ( ( 'Operation' ) )
-            // InternalRoom.g:7202:1: ( 'Operation' )
+            // InternalRoom.g:7400:1: ( ( 'Operation' ) )
+            // InternalRoom.g:7401:1: ( 'Operation' )
             {
-            // InternalRoom.g:7202:1: ( 'Operation' )
-            // InternalRoom.g:7203:1: 'Operation'
+            // InternalRoom.g:7401:1: ( 'Operation' )
+            // InternalRoom.g:7402:1: 'Operation'
             {
              before(grammarAccess.getStandardOperationAccess().getOperationKeyword_1()); 
             match(input,64,FOLLOW_2); 
@@ -21313,14 +21881,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__2"
-    // InternalRoom.g:7216:1: rule__StandardOperation__Group__2 : rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3 ;
+    // InternalRoom.g:7415:1: rule__StandardOperation__Group__2 : rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3 ;
     public final void rule__StandardOperation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7220:1: ( rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3 )
-            // InternalRoom.g:7221:2: rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3
+            // InternalRoom.g:7419:1: ( rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3 )
+            // InternalRoom.g:7420:2: rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3
             {
             pushFollow(FOLLOW_33);
             rule__StandardOperation__Group__2__Impl();
@@ -21351,21 +21919,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__2__Impl"
-    // InternalRoom.g:7228:1: rule__StandardOperation__Group__2__Impl : ( ( rule__StandardOperation__NameAssignment_2 ) ) ;
+    // InternalRoom.g:7427:1: rule__StandardOperation__Group__2__Impl : ( ( rule__StandardOperation__NameAssignment_2 ) ) ;
     public final void rule__StandardOperation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7232:1: ( ( ( rule__StandardOperation__NameAssignment_2 ) ) )
-            // InternalRoom.g:7233:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
+            // InternalRoom.g:7431:1: ( ( ( rule__StandardOperation__NameAssignment_2 ) ) )
+            // InternalRoom.g:7432:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
             {
-            // InternalRoom.g:7233:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
-            // InternalRoom.g:7234:1: ( rule__StandardOperation__NameAssignment_2 )
+            // InternalRoom.g:7432:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
+            // InternalRoom.g:7433:1: ( rule__StandardOperation__NameAssignment_2 )
             {
              before(grammarAccess.getStandardOperationAccess().getNameAssignment_2()); 
-            // InternalRoom.g:7235:1: ( rule__StandardOperation__NameAssignment_2 )
-            // InternalRoom.g:7235:2: rule__StandardOperation__NameAssignment_2
+            // InternalRoom.g:7434:1: ( rule__StandardOperation__NameAssignment_2 )
+            // InternalRoom.g:7434:2: rule__StandardOperation__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__NameAssignment_2();
@@ -21398,14 +21966,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__3"
-    // InternalRoom.g:7245:1: rule__StandardOperation__Group__3 : rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4 ;
+    // InternalRoom.g:7444:1: rule__StandardOperation__Group__3 : rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4 ;
     public final void rule__StandardOperation__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7249:1: ( rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4 )
-            // InternalRoom.g:7250:2: rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4
+            // InternalRoom.g:7448:1: ( rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4 )
+            // InternalRoom.g:7449:2: rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4
             {
             pushFollow(FOLLOW_34);
             rule__StandardOperation__Group__3__Impl();
@@ -21436,17 +22004,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__3__Impl"
-    // InternalRoom.g:7257:1: rule__StandardOperation__Group__3__Impl : ( '(' ) ;
+    // InternalRoom.g:7456:1: rule__StandardOperation__Group__3__Impl : ( '(' ) ;
     public final void rule__StandardOperation__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7261:1: ( ( '(' ) )
-            // InternalRoom.g:7262:1: ( '(' )
+            // InternalRoom.g:7460:1: ( ( '(' ) )
+            // InternalRoom.g:7461:1: ( '(' )
             {
-            // InternalRoom.g:7262:1: ( '(' )
-            // InternalRoom.g:7263:1: '('
+            // InternalRoom.g:7461:1: ( '(' )
+            // InternalRoom.g:7462:1: '('
             {
              before(grammarAccess.getStandardOperationAccess().getLeftParenthesisKeyword_3()); 
             match(input,50,FOLLOW_2); 
@@ -21473,14 +22041,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__4"
-    // InternalRoom.g:7276:1: rule__StandardOperation__Group__4 : rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5 ;
+    // InternalRoom.g:7475:1: rule__StandardOperation__Group__4 : rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5 ;
     public final void rule__StandardOperation__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7280:1: ( rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5 )
-            // InternalRoom.g:7281:2: rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5
+            // InternalRoom.g:7479:1: ( rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5 )
+            // InternalRoom.g:7480:2: rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5
             {
             pushFollow(FOLLOW_34);
             rule__StandardOperation__Group__4__Impl();
@@ -21511,29 +22079,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__4__Impl"
-    // InternalRoom.g:7288:1: rule__StandardOperation__Group__4__Impl : ( ( rule__StandardOperation__Group_4__0 )? ) ;
+    // InternalRoom.g:7487:1: rule__StandardOperation__Group__4__Impl : ( ( rule__StandardOperation__Group_4__0 )? ) ;
     public final void rule__StandardOperation__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7292:1: ( ( ( rule__StandardOperation__Group_4__0 )? ) )
-            // InternalRoom.g:7293:1: ( ( rule__StandardOperation__Group_4__0 )? )
+            // InternalRoom.g:7491:1: ( ( ( rule__StandardOperation__Group_4__0 )? ) )
+            // InternalRoom.g:7492:1: ( ( rule__StandardOperation__Group_4__0 )? )
             {
-            // InternalRoom.g:7293:1: ( ( rule__StandardOperation__Group_4__0 )? )
-            // InternalRoom.g:7294:1: ( rule__StandardOperation__Group_4__0 )?
+            // InternalRoom.g:7492:1: ( ( rule__StandardOperation__Group_4__0 )? )
+            // InternalRoom.g:7493:1: ( rule__StandardOperation__Group_4__0 )?
             {
              before(grammarAccess.getStandardOperationAccess().getGroup_4()); 
-            // InternalRoom.g:7295:1: ( rule__StandardOperation__Group_4__0 )?
-            int alt80=2;
-            int LA80_0 = input.LA(1);
+            // InternalRoom.g:7494:1: ( rule__StandardOperation__Group_4__0 )?
+            int alt82=2;
+            int LA82_0 = input.LA(1);
 
-            if ( (LA80_0==RULE_ID) ) {
-                alt80=1;
+            if ( (LA82_0==RULE_ID) ) {
+                alt82=1;
             }
-            switch (alt80) {
+            switch (alt82) {
                 case 1 :
-                    // InternalRoom.g:7295:2: rule__StandardOperation__Group_4__0
+                    // InternalRoom.g:7494:2: rule__StandardOperation__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__Group_4__0();
@@ -21569,14 +22137,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__5"
-    // InternalRoom.g:7305:1: rule__StandardOperation__Group__5 : rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6 ;
+    // InternalRoom.g:7504:1: rule__StandardOperation__Group__5 : rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6 ;
     public final void rule__StandardOperation__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7309:1: ( rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6 )
-            // InternalRoom.g:7310:2: rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6
+            // InternalRoom.g:7508:1: ( rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6 )
+            // InternalRoom.g:7509:2: rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__5__Impl();
@@ -21607,17 +22175,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__5__Impl"
-    // InternalRoom.g:7317:1: rule__StandardOperation__Group__5__Impl : ( ')' ) ;
+    // InternalRoom.g:7516:1: rule__StandardOperation__Group__5__Impl : ( ')' ) ;
     public final void rule__StandardOperation__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7321:1: ( ( ')' ) )
-            // InternalRoom.g:7322:1: ( ')' )
+            // InternalRoom.g:7520:1: ( ( ')' ) )
+            // InternalRoom.g:7521:1: ( ')' )
             {
-            // InternalRoom.g:7322:1: ( ')' )
-            // InternalRoom.g:7323:1: ')'
+            // InternalRoom.g:7521:1: ( ')' )
+            // InternalRoom.g:7522:1: ')'
             {
              before(grammarAccess.getStandardOperationAccess().getRightParenthesisKeyword_5()); 
             match(input,51,FOLLOW_2); 
@@ -21644,14 +22212,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__6"
-    // InternalRoom.g:7336:1: rule__StandardOperation__Group__6 : rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7 ;
+    // InternalRoom.g:7535:1: rule__StandardOperation__Group__6 : rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7 ;
     public final void rule__StandardOperation__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7340:1: ( rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7 )
-            // InternalRoom.g:7341:2: rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7
+            // InternalRoom.g:7539:1: ( rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7 )
+            // InternalRoom.g:7540:2: rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__6__Impl();
@@ -21682,29 +22250,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__6__Impl"
-    // InternalRoom.g:7348:1: rule__StandardOperation__Group__6__Impl : ( ( rule__StandardOperation__Group_6__0 )? ) ;
+    // InternalRoom.g:7547:1: rule__StandardOperation__Group__6__Impl : ( ( rule__StandardOperation__Group_6__0 )? ) ;
     public final void rule__StandardOperation__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7352:1: ( ( ( rule__StandardOperation__Group_6__0 )? ) )
-            // InternalRoom.g:7353:1: ( ( rule__StandardOperation__Group_6__0 )? )
+            // InternalRoom.g:7551:1: ( ( ( rule__StandardOperation__Group_6__0 )? ) )
+            // InternalRoom.g:7552:1: ( ( rule__StandardOperation__Group_6__0 )? )
             {
-            // InternalRoom.g:7353:1: ( ( rule__StandardOperation__Group_6__0 )? )
-            // InternalRoom.g:7354:1: ( rule__StandardOperation__Group_6__0 )?
+            // InternalRoom.g:7552:1: ( ( rule__StandardOperation__Group_6__0 )? )
+            // InternalRoom.g:7553:1: ( rule__StandardOperation__Group_6__0 )?
             {
              before(grammarAccess.getStandardOperationAccess().getGroup_6()); 
-            // InternalRoom.g:7355:1: ( rule__StandardOperation__Group_6__0 )?
-            int alt81=2;
-            int LA81_0 = input.LA(1);
+            // InternalRoom.g:7554:1: ( rule__StandardOperation__Group_6__0 )?
+            int alt83=2;
+            int LA83_0 = input.LA(1);
 
-            if ( (LA81_0==46) ) {
-                alt81=1;
+            if ( (LA83_0==46) ) {
+                alt83=1;
             }
-            switch (alt81) {
+            switch (alt83) {
                 case 1 :
-                    // InternalRoom.g:7355:2: rule__StandardOperation__Group_6__0
+                    // InternalRoom.g:7554:2: rule__StandardOperation__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__Group_6__0();
@@ -21740,14 +22308,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__7"
-    // InternalRoom.g:7365:1: rule__StandardOperation__Group__7 : rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8 ;
+    // InternalRoom.g:7564:1: rule__StandardOperation__Group__7 : rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8 ;
     public final void rule__StandardOperation__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7369:1: ( rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8 )
-            // InternalRoom.g:7370:2: rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8
+            // InternalRoom.g:7568:1: ( rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8 )
+            // InternalRoom.g:7569:2: rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__7__Impl();
@@ -21778,29 +22346,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__7__Impl"
-    // InternalRoom.g:7377:1: rule__StandardOperation__Group__7__Impl : ( ( rule__StandardOperation__DocuAssignment_7 )? ) ;
+    // InternalRoom.g:7576:1: rule__StandardOperation__Group__7__Impl : ( ( rule__StandardOperation__DocuAssignment_7 )? ) ;
     public final void rule__StandardOperation__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7381:1: ( ( ( rule__StandardOperation__DocuAssignment_7 )? ) )
-            // InternalRoom.g:7382:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
+            // InternalRoom.g:7580:1: ( ( ( rule__StandardOperation__DocuAssignment_7 )? ) )
+            // InternalRoom.g:7581:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
             {
-            // InternalRoom.g:7382:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
-            // InternalRoom.g:7383:1: ( rule__StandardOperation__DocuAssignment_7 )?
+            // InternalRoom.g:7581:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
+            // InternalRoom.g:7582:1: ( rule__StandardOperation__DocuAssignment_7 )?
             {
              before(grammarAccess.getStandardOperationAccess().getDocuAssignment_7()); 
-            // InternalRoom.g:7384:1: ( rule__StandardOperation__DocuAssignment_7 )?
-            int alt82=2;
-            int LA82_0 = input.LA(1);
+            // InternalRoom.g:7583:1: ( rule__StandardOperation__DocuAssignment_7 )?
+            int alt84=2;
+            int LA84_0 = input.LA(1);
 
-            if ( (LA82_0==62) ) {
-                alt82=1;
+            if ( (LA84_0==62) ) {
+                alt84=1;
             }
-            switch (alt82) {
+            switch (alt84) {
                 case 1 :
-                    // InternalRoom.g:7384:2: rule__StandardOperation__DocuAssignment_7
+                    // InternalRoom.g:7583:2: rule__StandardOperation__DocuAssignment_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__DocuAssignment_7();
@@ -21836,14 +22404,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__8"
-    // InternalRoom.g:7394:1: rule__StandardOperation__Group__8 : rule__StandardOperation__Group__8__Impl ;
+    // InternalRoom.g:7593:1: rule__StandardOperation__Group__8 : rule__StandardOperation__Group__8__Impl ;
     public final void rule__StandardOperation__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7398:1: ( rule__StandardOperation__Group__8__Impl )
-            // InternalRoom.g:7399:2: rule__StandardOperation__Group__8__Impl
+            // InternalRoom.g:7597:1: ( rule__StandardOperation__Group__8__Impl )
+            // InternalRoom.g:7598:2: rule__StandardOperation__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group__8__Impl();
@@ -21869,21 +22437,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__8__Impl"
-    // InternalRoom.g:7405:1: rule__StandardOperation__Group__8__Impl : ( ( rule__StandardOperation__DetailCodeAssignment_8 ) ) ;
+    // InternalRoom.g:7604:1: rule__StandardOperation__Group__8__Impl : ( ( rule__StandardOperation__DetailCodeAssignment_8 ) ) ;
     public final void rule__StandardOperation__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7409:1: ( ( ( rule__StandardOperation__DetailCodeAssignment_8 ) ) )
-            // InternalRoom.g:7410:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
+            // InternalRoom.g:7608:1: ( ( ( rule__StandardOperation__DetailCodeAssignment_8 ) ) )
+            // InternalRoom.g:7609:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
             {
-            // InternalRoom.g:7410:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
-            // InternalRoom.g:7411:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
+            // InternalRoom.g:7609:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
+            // InternalRoom.g:7610:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
             {
              before(grammarAccess.getStandardOperationAccess().getDetailCodeAssignment_8()); 
-            // InternalRoom.g:7412:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
-            // InternalRoom.g:7412:2: rule__StandardOperation__DetailCodeAssignment_8
+            // InternalRoom.g:7611:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
+            // InternalRoom.g:7611:2: rule__StandardOperation__DetailCodeAssignment_8
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__DetailCodeAssignment_8();
@@ -21916,14 +22484,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4__0"
-    // InternalRoom.g:7440:1: rule__StandardOperation__Group_4__0 : rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1 ;
+    // InternalRoom.g:7639:1: rule__StandardOperation__Group_4__0 : rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1 ;
     public final void rule__StandardOperation__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7444:1: ( rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1 )
-            // InternalRoom.g:7445:2: rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1
+            // InternalRoom.g:7643:1: ( rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1 )
+            // InternalRoom.g:7644:2: rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1
             {
             pushFollow(FOLLOW_18);
             rule__StandardOperation__Group_4__0__Impl();
@@ -21954,21 +22522,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4__0__Impl"
-    // InternalRoom.g:7452:1: rule__StandardOperation__Group_4__0__Impl : ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) ) ;
+    // InternalRoom.g:7651:1: rule__StandardOperation__Group_4__0__Impl : ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) ) ;
     public final void rule__StandardOperation__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7456:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) ) )
-            // InternalRoom.g:7457:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) )
+            // InternalRoom.g:7655:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) ) )
+            // InternalRoom.g:7656:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) )
             {
-            // InternalRoom.g:7457:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) )
-            // InternalRoom.g:7458:1: ( rule__StandardOperation__ArgumentsAssignment_4_0 )
+            // InternalRoom.g:7656:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) )
+            // InternalRoom.g:7657:1: ( rule__StandardOperation__ArgumentsAssignment_4_0 )
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_0()); 
-            // InternalRoom.g:7459:1: ( rule__StandardOperation__ArgumentsAssignment_4_0 )
-            // InternalRoom.g:7459:2: rule__StandardOperation__ArgumentsAssignment_4_0
+            // InternalRoom.g:7658:1: ( rule__StandardOperation__ArgumentsAssignment_4_0 )
+            // InternalRoom.g:7658:2: rule__StandardOperation__ArgumentsAssignment_4_0
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__ArgumentsAssignment_4_0();
@@ -22001,14 +22569,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4__1"
-    // InternalRoom.g:7469:1: rule__StandardOperation__Group_4__1 : rule__StandardOperation__Group_4__1__Impl ;
+    // InternalRoom.g:7668:1: rule__StandardOperation__Group_4__1 : rule__StandardOperation__Group_4__1__Impl ;
     public final void rule__StandardOperation__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7473:1: ( rule__StandardOperation__Group_4__1__Impl )
-            // InternalRoom.g:7474:2: rule__StandardOperation__Group_4__1__Impl
+            // InternalRoom.g:7672:1: ( rule__StandardOperation__Group_4__1__Impl )
+            // InternalRoom.g:7673:2: rule__StandardOperation__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_4__1__Impl();
@@ -22034,33 +22602,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4__1__Impl"
-    // InternalRoom.g:7480:1: rule__StandardOperation__Group_4__1__Impl : ( ( rule__StandardOperation__Group_4_1__0 )* ) ;
+    // InternalRoom.g:7679:1: rule__StandardOperation__Group_4__1__Impl : ( ( rule__StandardOperation__Group_4_1__0 )* ) ;
     public final void rule__StandardOperation__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7484:1: ( ( ( rule__StandardOperation__Group_4_1__0 )* ) )
-            // InternalRoom.g:7485:1: ( ( rule__StandardOperation__Group_4_1__0 )* )
+            // InternalRoom.g:7683:1: ( ( ( rule__StandardOperation__Group_4_1__0 )* ) )
+            // InternalRoom.g:7684:1: ( ( rule__StandardOperation__Group_4_1__0 )* )
             {
-            // InternalRoom.g:7485:1: ( ( rule__StandardOperation__Group_4_1__0 )* )
-            // InternalRoom.g:7486:1: ( rule__StandardOperation__Group_4_1__0 )*
+            // InternalRoom.g:7684:1: ( ( rule__StandardOperation__Group_4_1__0 )* )
+            // InternalRoom.g:7685:1: ( rule__StandardOperation__Group_4_1__0 )*
             {
              before(grammarAccess.getStandardOperationAccess().getGroup_4_1()); 
-            // InternalRoom.g:7487:1: ( rule__StandardOperation__Group_4_1__0 )*
-            loop83:
+            // InternalRoom.g:7686:1: ( rule__StandardOperation__Group_4_1__0 )*
+            loop85:
             do {
-                int alt83=2;
-                int LA83_0 = input.LA(1);
+                int alt85=2;
+                int LA85_0 = input.LA(1);
 
-                if ( (LA83_0==54) ) {
-                    alt83=1;
+                if ( (LA85_0==54) ) {
+                    alt85=1;
                 }
 
 
-                switch (alt83) {
+                switch (alt85) {
             	case 1 :
-            	    // InternalRoom.g:7487:2: rule__StandardOperation__Group_4_1__0
+            	    // InternalRoom.g:7686:2: rule__StandardOperation__Group_4_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__StandardOperation__Group_4_1__0();
@@ -22072,7 +22640,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop83;
+            	    break loop85;
                 }
             } while (true);
 
@@ -22099,14 +22667,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4_1__0"
-    // InternalRoom.g:7501:1: rule__StandardOperation__Group_4_1__0 : rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1 ;
+    // InternalRoom.g:7700:1: rule__StandardOperation__Group_4_1__0 : rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1 ;
     public final void rule__StandardOperation__Group_4_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7505:1: ( rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1 )
-            // InternalRoom.g:7506:2: rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1
+            // InternalRoom.g:7704:1: ( rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1 )
+            // InternalRoom.g:7705:2: rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1
             {
             pushFollow(FOLLOW_3);
             rule__StandardOperation__Group_4_1__0__Impl();
@@ -22137,17 +22705,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4_1__0__Impl"
-    // InternalRoom.g:7513:1: rule__StandardOperation__Group_4_1__0__Impl : ( ',' ) ;
+    // InternalRoom.g:7712:1: rule__StandardOperation__Group_4_1__0__Impl : ( ',' ) ;
     public final void rule__StandardOperation__Group_4_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7517:1: ( ( ',' ) )
-            // InternalRoom.g:7518:1: ( ',' )
+            // InternalRoom.g:7716:1: ( ( ',' ) )
+            // InternalRoom.g:7717:1: ( ',' )
             {
-            // InternalRoom.g:7518:1: ( ',' )
-            // InternalRoom.g:7519:1: ','
+            // InternalRoom.g:7717:1: ( ',' )
+            // InternalRoom.g:7718:1: ','
             {
              before(grammarAccess.getStandardOperationAccess().getCommaKeyword_4_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -22174,14 +22742,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4_1__1"
-    // InternalRoom.g:7532:1: rule__StandardOperation__Group_4_1__1 : rule__StandardOperation__Group_4_1__1__Impl ;
+    // InternalRoom.g:7731:1: rule__StandardOperation__Group_4_1__1 : rule__StandardOperation__Group_4_1__1__Impl ;
     public final void rule__StandardOperation__Group_4_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7536:1: ( rule__StandardOperation__Group_4_1__1__Impl )
-            // InternalRoom.g:7537:2: rule__StandardOperation__Group_4_1__1__Impl
+            // InternalRoom.g:7735:1: ( rule__StandardOperation__Group_4_1__1__Impl )
+            // InternalRoom.g:7736:2: rule__StandardOperation__Group_4_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_4_1__1__Impl();
@@ -22207,21 +22775,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_4_1__1__Impl"
-    // InternalRoom.g:7543:1: rule__StandardOperation__Group_4_1__1__Impl : ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) ) ;
+    // InternalRoom.g:7742:1: rule__StandardOperation__Group_4_1__1__Impl : ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) ) ;
     public final void rule__StandardOperation__Group_4_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7547:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) ) )
-            // InternalRoom.g:7548:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) )
+            // InternalRoom.g:7746:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) ) )
+            // InternalRoom.g:7747:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) )
             {
-            // InternalRoom.g:7548:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) )
-            // InternalRoom.g:7549:1: ( rule__StandardOperation__ArgumentsAssignment_4_1_1 )
+            // InternalRoom.g:7747:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) )
+            // InternalRoom.g:7748:1: ( rule__StandardOperation__ArgumentsAssignment_4_1_1 )
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_1_1()); 
-            // InternalRoom.g:7550:1: ( rule__StandardOperation__ArgumentsAssignment_4_1_1 )
-            // InternalRoom.g:7550:2: rule__StandardOperation__ArgumentsAssignment_4_1_1
+            // InternalRoom.g:7749:1: ( rule__StandardOperation__ArgumentsAssignment_4_1_1 )
+            // InternalRoom.g:7749:2: rule__StandardOperation__ArgumentsAssignment_4_1_1
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__ArgumentsAssignment_4_1_1();
@@ -22254,14 +22822,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_6__0"
-    // InternalRoom.g:7564:1: rule__StandardOperation__Group_6__0 : rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1 ;
+    // InternalRoom.g:7763:1: rule__StandardOperation__Group_6__0 : rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1 ;
     public final void rule__StandardOperation__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7568:1: ( rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1 )
-            // InternalRoom.g:7569:2: rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1
+            // InternalRoom.g:7767:1: ( rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1 )
+            // InternalRoom.g:7768:2: rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1
             {
             pushFollow(FOLLOW_36);
             rule__StandardOperation__Group_6__0__Impl();
@@ -22292,17 +22860,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_6__0__Impl"
-    // InternalRoom.g:7576:1: rule__StandardOperation__Group_6__0__Impl : ( ':' ) ;
+    // InternalRoom.g:7775:1: rule__StandardOperation__Group_6__0__Impl : ( ':' ) ;
     public final void rule__StandardOperation__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7580:1: ( ( ':' ) )
-            // InternalRoom.g:7581:1: ( ':' )
+            // InternalRoom.g:7779:1: ( ( ':' ) )
+            // InternalRoom.g:7780:1: ( ':' )
             {
-            // InternalRoom.g:7581:1: ( ':' )
-            // InternalRoom.g:7582:1: ':'
+            // InternalRoom.g:7780:1: ( ':' )
+            // InternalRoom.g:7781:1: ':'
             {
              before(grammarAccess.getStandardOperationAccess().getColonKeyword_6_0()); 
             match(input,46,FOLLOW_2); 
@@ -22329,14 +22897,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_6__1"
-    // InternalRoom.g:7595:1: rule__StandardOperation__Group_6__1 : rule__StandardOperation__Group_6__1__Impl ;
+    // InternalRoom.g:7794:1: rule__StandardOperation__Group_6__1 : rule__StandardOperation__Group_6__1__Impl ;
     public final void rule__StandardOperation__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7599:1: ( rule__StandardOperation__Group_6__1__Impl )
-            // InternalRoom.g:7600:2: rule__StandardOperation__Group_6__1__Impl
+            // InternalRoom.g:7798:1: ( rule__StandardOperation__Group_6__1__Impl )
+            // InternalRoom.g:7799:2: rule__StandardOperation__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_6__1__Impl();
@@ -22362,21 +22930,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group_6__1__Impl"
-    // InternalRoom.g:7606:1: rule__StandardOperation__Group_6__1__Impl : ( ( rule__StandardOperation__Alternatives_6_1 ) ) ;
+    // InternalRoom.g:7805:1: rule__StandardOperation__Group_6__1__Impl : ( ( rule__StandardOperation__Alternatives_6_1 ) ) ;
     public final void rule__StandardOperation__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7610:1: ( ( ( rule__StandardOperation__Alternatives_6_1 ) ) )
-            // InternalRoom.g:7611:1: ( ( rule__StandardOperation__Alternatives_6_1 ) )
+            // InternalRoom.g:7809:1: ( ( ( rule__StandardOperation__Alternatives_6_1 ) ) )
+            // InternalRoom.g:7810:1: ( ( rule__StandardOperation__Alternatives_6_1 ) )
             {
-            // InternalRoom.g:7611:1: ( ( rule__StandardOperation__Alternatives_6_1 ) )
-            // InternalRoom.g:7612:1: ( rule__StandardOperation__Alternatives_6_1 )
+            // InternalRoom.g:7810:1: ( ( rule__StandardOperation__Alternatives_6_1 ) )
+            // InternalRoom.g:7811:1: ( rule__StandardOperation__Alternatives_6_1 )
             {
              before(grammarAccess.getStandardOperationAccess().getAlternatives_6_1()); 
-            // InternalRoom.g:7613:1: ( rule__StandardOperation__Alternatives_6_1 )
-            // InternalRoom.g:7613:2: rule__StandardOperation__Alternatives_6_1
+            // InternalRoom.g:7812:1: ( rule__StandardOperation__Alternatives_6_1 )
+            // InternalRoom.g:7812:2: rule__StandardOperation__Alternatives_6_1
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Alternatives_6_1();
@@ -22409,14 +22977,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__0"
-    // InternalRoom.g:7627:1: rule__PortOperation__Group__0 : rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1 ;
+    // InternalRoom.g:7826:1: rule__PortOperation__Group__0 : rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1 ;
     public final void rule__PortOperation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7631:1: ( rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1 )
-            // InternalRoom.g:7632:2: rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1
+            // InternalRoom.g:7830:1: ( rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1 )
+            // InternalRoom.g:7831:2: rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__PortOperation__Group__0__Impl();
@@ -22447,17 +23015,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__0__Impl"
-    // InternalRoom.g:7639:1: rule__PortOperation__Group__0__Impl : ( 'Operation' ) ;
+    // InternalRoom.g:7838:1: rule__PortOperation__Group__0__Impl : ( 'Operation' ) ;
     public final void rule__PortOperation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7643:1: ( ( 'Operation' ) )
-            // InternalRoom.g:7644:1: ( 'Operation' )
+            // InternalRoom.g:7842:1: ( ( 'Operation' ) )
+            // InternalRoom.g:7843:1: ( 'Operation' )
             {
-            // InternalRoom.g:7644:1: ( 'Operation' )
-            // InternalRoom.g:7645:1: 'Operation'
+            // InternalRoom.g:7843:1: ( 'Operation' )
+            // InternalRoom.g:7844:1: 'Operation'
             {
              before(grammarAccess.getPortOperationAccess().getOperationKeyword_0()); 
             match(input,64,FOLLOW_2); 
@@ -22484,14 +23052,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__1"
-    // InternalRoom.g:7658:1: rule__PortOperation__Group__1 : rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2 ;
+    // InternalRoom.g:7857:1: rule__PortOperation__Group__1 : rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2 ;
     public final void rule__PortOperation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7662:1: ( rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2 )
-            // InternalRoom.g:7663:2: rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2
+            // InternalRoom.g:7861:1: ( rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2 )
+            // InternalRoom.g:7862:2: rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2
             {
             pushFollow(FOLLOW_33);
             rule__PortOperation__Group__1__Impl();
@@ -22522,21 +23090,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__1__Impl"
-    // InternalRoom.g:7670:1: rule__PortOperation__Group__1__Impl : ( ( rule__PortOperation__NameAssignment_1 ) ) ;
+    // InternalRoom.g:7869:1: rule__PortOperation__Group__1__Impl : ( ( rule__PortOperation__NameAssignment_1 ) ) ;
     public final void rule__PortOperation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7674:1: ( ( ( rule__PortOperation__NameAssignment_1 ) ) )
-            // InternalRoom.g:7675:1: ( ( rule__PortOperation__NameAssignment_1 ) )
+            // InternalRoom.g:7873:1: ( ( ( rule__PortOperation__NameAssignment_1 ) ) )
+            // InternalRoom.g:7874:1: ( ( rule__PortOperation__NameAssignment_1 ) )
             {
-            // InternalRoom.g:7675:1: ( ( rule__PortOperation__NameAssignment_1 ) )
-            // InternalRoom.g:7676:1: ( rule__PortOperation__NameAssignment_1 )
+            // InternalRoom.g:7874:1: ( ( rule__PortOperation__NameAssignment_1 ) )
+            // InternalRoom.g:7875:1: ( rule__PortOperation__NameAssignment_1 )
             {
              before(grammarAccess.getPortOperationAccess().getNameAssignment_1()); 
-            // InternalRoom.g:7677:1: ( rule__PortOperation__NameAssignment_1 )
-            // InternalRoom.g:7677:2: rule__PortOperation__NameAssignment_1
+            // InternalRoom.g:7876:1: ( rule__PortOperation__NameAssignment_1 )
+            // InternalRoom.g:7876:2: rule__PortOperation__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__NameAssignment_1();
@@ -22569,14 +23137,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__2"
-    // InternalRoom.g:7687:1: rule__PortOperation__Group__2 : rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3 ;
+    // InternalRoom.g:7886:1: rule__PortOperation__Group__2 : rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3 ;
     public final void rule__PortOperation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7691:1: ( rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3 )
-            // InternalRoom.g:7692:2: rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3
+            // InternalRoom.g:7890:1: ( rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3 )
+            // InternalRoom.g:7891:2: rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3
             {
             pushFollow(FOLLOW_34);
             rule__PortOperation__Group__2__Impl();
@@ -22607,17 +23175,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__2__Impl"
-    // InternalRoom.g:7699:1: rule__PortOperation__Group__2__Impl : ( '(' ) ;
+    // InternalRoom.g:7898:1: rule__PortOperation__Group__2__Impl : ( '(' ) ;
     public final void rule__PortOperation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7703:1: ( ( '(' ) )
-            // InternalRoom.g:7704:1: ( '(' )
+            // InternalRoom.g:7902:1: ( ( '(' ) )
+            // InternalRoom.g:7903:1: ( '(' )
             {
-            // InternalRoom.g:7704:1: ( '(' )
-            // InternalRoom.g:7705:1: '('
+            // InternalRoom.g:7903:1: ( '(' )
+            // InternalRoom.g:7904:1: '('
             {
              before(grammarAccess.getPortOperationAccess().getLeftParenthesisKeyword_2()); 
             match(input,50,FOLLOW_2); 
@@ -22644,14 +23212,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__3"
-    // InternalRoom.g:7718:1: rule__PortOperation__Group__3 : rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4 ;
+    // InternalRoom.g:7917:1: rule__PortOperation__Group__3 : rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4 ;
     public final void rule__PortOperation__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7722:1: ( rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4 )
-            // InternalRoom.g:7723:2: rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4
+            // InternalRoom.g:7921:1: ( rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4 )
+            // InternalRoom.g:7922:2: rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4
             {
             pushFollow(FOLLOW_34);
             rule__PortOperation__Group__3__Impl();
@@ -22682,29 +23250,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__3__Impl"
-    // InternalRoom.g:7730:1: rule__PortOperation__Group__3__Impl : ( ( rule__PortOperation__Group_3__0 )? ) ;
+    // InternalRoom.g:7929:1: rule__PortOperation__Group__3__Impl : ( ( rule__PortOperation__Group_3__0 )? ) ;
     public final void rule__PortOperation__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7734:1: ( ( ( rule__PortOperation__Group_3__0 )? ) )
-            // InternalRoom.g:7735:1: ( ( rule__PortOperation__Group_3__0 )? )
+            // InternalRoom.g:7933:1: ( ( ( rule__PortOperation__Group_3__0 )? ) )
+            // InternalRoom.g:7934:1: ( ( rule__PortOperation__Group_3__0 )? )
             {
-            // InternalRoom.g:7735:1: ( ( rule__PortOperation__Group_3__0 )? )
-            // InternalRoom.g:7736:1: ( rule__PortOperation__Group_3__0 )?
+            // InternalRoom.g:7934:1: ( ( rule__PortOperation__Group_3__0 )? )
+            // InternalRoom.g:7935:1: ( rule__PortOperation__Group_3__0 )?
             {
              before(grammarAccess.getPortOperationAccess().getGroup_3()); 
-            // InternalRoom.g:7737:1: ( rule__PortOperation__Group_3__0 )?
-            int alt84=2;
-            int LA84_0 = input.LA(1);
+            // InternalRoom.g:7936:1: ( rule__PortOperation__Group_3__0 )?
+            int alt86=2;
+            int LA86_0 = input.LA(1);
 
-            if ( (LA84_0==RULE_ID) ) {
-                alt84=1;
+            if ( (LA86_0==RULE_ID) ) {
+                alt86=1;
             }
-            switch (alt84) {
+            switch (alt86) {
                 case 1 :
-                    // InternalRoom.g:7737:2: rule__PortOperation__Group_3__0
+                    // InternalRoom.g:7936:2: rule__PortOperation__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_3__0();
@@ -22740,14 +23308,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__4"
-    // InternalRoom.g:7747:1: rule__PortOperation__Group__4 : rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5 ;
+    // InternalRoom.g:7946:1: rule__PortOperation__Group__4 : rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5 ;
     public final void rule__PortOperation__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7751:1: ( rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5 )
-            // InternalRoom.g:7752:2: rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5
+            // InternalRoom.g:7950:1: ( rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5 )
+            // InternalRoom.g:7951:2: rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__4__Impl();
@@ -22778,17 +23346,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__4__Impl"
-    // InternalRoom.g:7759:1: rule__PortOperation__Group__4__Impl : ( ')' ) ;
+    // InternalRoom.g:7958:1: rule__PortOperation__Group__4__Impl : ( ')' ) ;
     public final void rule__PortOperation__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7763:1: ( ( ')' ) )
-            // InternalRoom.g:7764:1: ( ')' )
+            // InternalRoom.g:7962:1: ( ( ')' ) )
+            // InternalRoom.g:7963:1: ( ')' )
             {
-            // InternalRoom.g:7764:1: ( ')' )
-            // InternalRoom.g:7765:1: ')'
+            // InternalRoom.g:7963:1: ( ')' )
+            // InternalRoom.g:7964:1: ')'
             {
              before(grammarAccess.getPortOperationAccess().getRightParenthesisKeyword_4()); 
             match(input,51,FOLLOW_2); 
@@ -22815,14 +23383,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__5"
-    // InternalRoom.g:7778:1: rule__PortOperation__Group__5 : rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6 ;
+    // InternalRoom.g:7977:1: rule__PortOperation__Group__5 : rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6 ;
     public final void rule__PortOperation__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7782:1: ( rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6 )
-            // InternalRoom.g:7783:2: rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6
+            // InternalRoom.g:7981:1: ( rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6 )
+            // InternalRoom.g:7982:2: rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__5__Impl();
@@ -22853,29 +23421,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__5__Impl"
-    // InternalRoom.g:7790:1: rule__PortOperation__Group__5__Impl : ( ( rule__PortOperation__Alternatives_5 )? ) ;
+    // InternalRoom.g:7989:1: rule__PortOperation__Group__5__Impl : ( ( rule__PortOperation__Alternatives_5 )? ) ;
     public final void rule__PortOperation__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7794:1: ( ( ( rule__PortOperation__Alternatives_5 )? ) )
-            // InternalRoom.g:7795:1: ( ( rule__PortOperation__Alternatives_5 )? )
+            // InternalRoom.g:7993:1: ( ( ( rule__PortOperation__Alternatives_5 )? ) )
+            // InternalRoom.g:7994:1: ( ( rule__PortOperation__Alternatives_5 )? )
             {
-            // InternalRoom.g:7795:1: ( ( rule__PortOperation__Alternatives_5 )? )
-            // InternalRoom.g:7796:1: ( rule__PortOperation__Alternatives_5 )?
+            // InternalRoom.g:7994:1: ( ( rule__PortOperation__Alternatives_5 )? )
+            // InternalRoom.g:7995:1: ( rule__PortOperation__Alternatives_5 )?
             {
              before(grammarAccess.getPortOperationAccess().getAlternatives_5()); 
-            // InternalRoom.g:7797:1: ( rule__PortOperation__Alternatives_5 )?
-            int alt85=2;
-            int LA85_0 = input.LA(1);
+            // InternalRoom.g:7996:1: ( rule__PortOperation__Alternatives_5 )?
+            int alt87=2;
+            int LA87_0 = input.LA(1);
 
-            if ( (LA85_0==46||LA85_0==65) ) {
-                alt85=1;
+            if ( (LA87_0==46||LA87_0==65) ) {
+                alt87=1;
             }
-            switch (alt85) {
+            switch (alt87) {
                 case 1 :
-                    // InternalRoom.g:7797:2: rule__PortOperation__Alternatives_5
+                    // InternalRoom.g:7996:2: rule__PortOperation__Alternatives_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Alternatives_5();
@@ -22911,14 +23479,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__6"
-    // InternalRoom.g:7807:1: rule__PortOperation__Group__6 : rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7 ;
+    // InternalRoom.g:8006:1: rule__PortOperation__Group__6 : rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7 ;
     public final void rule__PortOperation__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7811:1: ( rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7 )
-            // InternalRoom.g:7812:2: rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7
+            // InternalRoom.g:8010:1: ( rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7 )
+            // InternalRoom.g:8011:2: rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__6__Impl();
@@ -22949,29 +23517,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__6__Impl"
-    // InternalRoom.g:7819:1: rule__PortOperation__Group__6__Impl : ( ( rule__PortOperation__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:8018:1: rule__PortOperation__Group__6__Impl : ( ( rule__PortOperation__DocuAssignment_6 )? ) ;
     public final void rule__PortOperation__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7823:1: ( ( ( rule__PortOperation__DocuAssignment_6 )? ) )
-            // InternalRoom.g:7824:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
+            // InternalRoom.g:8022:1: ( ( ( rule__PortOperation__DocuAssignment_6 )? ) )
+            // InternalRoom.g:8023:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:7824:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
-            // InternalRoom.g:7825:1: ( rule__PortOperation__DocuAssignment_6 )?
+            // InternalRoom.g:8023:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
+            // InternalRoom.g:8024:1: ( rule__PortOperation__DocuAssignment_6 )?
             {
              before(grammarAccess.getPortOperationAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:7826:1: ( rule__PortOperation__DocuAssignment_6 )?
-            int alt86=2;
-            int LA86_0 = input.LA(1);
+            // InternalRoom.g:8025:1: ( rule__PortOperation__DocuAssignment_6 )?
+            int alt88=2;
+            int LA88_0 = input.LA(1);
 
-            if ( (LA86_0==62) ) {
-                alt86=1;
+            if ( (LA88_0==62) ) {
+                alt88=1;
             }
-            switch (alt86) {
+            switch (alt88) {
                 case 1 :
-                    // InternalRoom.g:7826:2: rule__PortOperation__DocuAssignment_6
+                    // InternalRoom.g:8025:2: rule__PortOperation__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__DocuAssignment_6();
@@ -23007,14 +23575,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__7"
-    // InternalRoom.g:7836:1: rule__PortOperation__Group__7 : rule__PortOperation__Group__7__Impl ;
+    // InternalRoom.g:8035:1: rule__PortOperation__Group__7 : rule__PortOperation__Group__7__Impl ;
     public final void rule__PortOperation__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7840:1: ( rule__PortOperation__Group__7__Impl )
-            // InternalRoom.g:7841:2: rule__PortOperation__Group__7__Impl
+            // InternalRoom.g:8039:1: ( rule__PortOperation__Group__7__Impl )
+            // InternalRoom.g:8040:2: rule__PortOperation__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group__7__Impl();
@@ -23040,21 +23608,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__7__Impl"
-    // InternalRoom.g:7847:1: rule__PortOperation__Group__7__Impl : ( ( rule__PortOperation__DetailCodeAssignment_7 ) ) ;
+    // InternalRoom.g:8046:1: rule__PortOperation__Group__7__Impl : ( ( rule__PortOperation__DetailCodeAssignment_7 ) ) ;
     public final void rule__PortOperation__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7851:1: ( ( ( rule__PortOperation__DetailCodeAssignment_7 ) ) )
-            // InternalRoom.g:7852:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
+            // InternalRoom.g:8050:1: ( ( ( rule__PortOperation__DetailCodeAssignment_7 ) ) )
+            // InternalRoom.g:8051:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
             {
-            // InternalRoom.g:7852:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
-            // InternalRoom.g:7853:1: ( rule__PortOperation__DetailCodeAssignment_7 )
+            // InternalRoom.g:8051:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
+            // InternalRoom.g:8052:1: ( rule__PortOperation__DetailCodeAssignment_7 )
             {
              before(grammarAccess.getPortOperationAccess().getDetailCodeAssignment_7()); 
-            // InternalRoom.g:7854:1: ( rule__PortOperation__DetailCodeAssignment_7 )
-            // InternalRoom.g:7854:2: rule__PortOperation__DetailCodeAssignment_7
+            // InternalRoom.g:8053:1: ( rule__PortOperation__DetailCodeAssignment_7 )
+            // InternalRoom.g:8053:2: rule__PortOperation__DetailCodeAssignment_7
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__DetailCodeAssignment_7();
@@ -23087,14 +23655,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3__0"
-    // InternalRoom.g:7880:1: rule__PortOperation__Group_3__0 : rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1 ;
+    // InternalRoom.g:8079:1: rule__PortOperation__Group_3__0 : rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1 ;
     public final void rule__PortOperation__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7884:1: ( rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1 )
-            // InternalRoom.g:7885:2: rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1
+            // InternalRoom.g:8083:1: ( rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1 )
+            // InternalRoom.g:8084:2: rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1
             {
             pushFollow(FOLLOW_18);
             rule__PortOperation__Group_3__0__Impl();
@@ -23125,21 +23693,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3__0__Impl"
-    // InternalRoom.g:7892:1: rule__PortOperation__Group_3__0__Impl : ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) ) ;
+    // InternalRoom.g:8091:1: rule__PortOperation__Group_3__0__Impl : ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) ) ;
     public final void rule__PortOperation__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7896:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) ) )
-            // InternalRoom.g:7897:1: ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) )
+            // InternalRoom.g:8095:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) ) )
+            // InternalRoom.g:8096:1: ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) )
             {
-            // InternalRoom.g:7897:1: ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) )
-            // InternalRoom.g:7898:1: ( rule__PortOperation__ArgumentsAssignment_3_0 )
+            // InternalRoom.g:8096:1: ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) )
+            // InternalRoom.g:8097:1: ( rule__PortOperation__ArgumentsAssignment_3_0 )
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_0()); 
-            // InternalRoom.g:7899:1: ( rule__PortOperation__ArgumentsAssignment_3_0 )
-            // InternalRoom.g:7899:2: rule__PortOperation__ArgumentsAssignment_3_0
+            // InternalRoom.g:8098:1: ( rule__PortOperation__ArgumentsAssignment_3_0 )
+            // InternalRoom.g:8098:2: rule__PortOperation__ArgumentsAssignment_3_0
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__ArgumentsAssignment_3_0();
@@ -23172,14 +23740,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3__1"
-    // InternalRoom.g:7909:1: rule__PortOperation__Group_3__1 : rule__PortOperation__Group_3__1__Impl ;
+    // InternalRoom.g:8108:1: rule__PortOperation__Group_3__1 : rule__PortOperation__Group_3__1__Impl ;
     public final void rule__PortOperation__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7913:1: ( rule__PortOperation__Group_3__1__Impl )
-            // InternalRoom.g:7914:2: rule__PortOperation__Group_3__1__Impl
+            // InternalRoom.g:8112:1: ( rule__PortOperation__Group_3__1__Impl )
+            // InternalRoom.g:8113:2: rule__PortOperation__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_3__1__Impl();
@@ -23205,33 +23773,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3__1__Impl"
-    // InternalRoom.g:7920:1: rule__PortOperation__Group_3__1__Impl : ( ( rule__PortOperation__Group_3_1__0 )* ) ;
+    // InternalRoom.g:8119:1: rule__PortOperation__Group_3__1__Impl : ( ( rule__PortOperation__Group_3_1__0 )* ) ;
     public final void rule__PortOperation__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7924:1: ( ( ( rule__PortOperation__Group_3_1__0 )* ) )
-            // InternalRoom.g:7925:1: ( ( rule__PortOperation__Group_3_1__0 )* )
+            // InternalRoom.g:8123:1: ( ( ( rule__PortOperation__Group_3_1__0 )* ) )
+            // InternalRoom.g:8124:1: ( ( rule__PortOperation__Group_3_1__0 )* )
             {
-            // InternalRoom.g:7925:1: ( ( rule__PortOperation__Group_3_1__0 )* )
-            // InternalRoom.g:7926:1: ( rule__PortOperation__Group_3_1__0 )*
+            // InternalRoom.g:8124:1: ( ( rule__PortOperation__Group_3_1__0 )* )
+            // InternalRoom.g:8125:1: ( rule__PortOperation__Group_3_1__0 )*
             {
              before(grammarAccess.getPortOperationAccess().getGroup_3_1()); 
-            // InternalRoom.g:7927:1: ( rule__PortOperation__Group_3_1__0 )*
-            loop87:
+            // InternalRoom.g:8126:1: ( rule__PortOperation__Group_3_1__0 )*
+            loop89:
             do {
-                int alt87=2;
-                int LA87_0 = input.LA(1);
+                int alt89=2;
+                int LA89_0 = input.LA(1);
 
-                if ( (LA87_0==54) ) {
-                    alt87=1;
+                if ( (LA89_0==54) ) {
+                    alt89=1;
                 }
 
 
-                switch (alt87) {
+                switch (alt89) {
             	case 1 :
-            	    // InternalRoom.g:7927:2: rule__PortOperation__Group_3_1__0
+            	    // InternalRoom.g:8126:2: rule__PortOperation__Group_3_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__PortOperation__Group_3_1__0();
@@ -23243,7 +23811,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop87;
+            	    break loop89;
                 }
             } while (true);
 
@@ -23270,14 +23838,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3_1__0"
-    // InternalRoom.g:7941:1: rule__PortOperation__Group_3_1__0 : rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1 ;
+    // InternalRoom.g:8140:1: rule__PortOperation__Group_3_1__0 : rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1 ;
     public final void rule__PortOperation__Group_3_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7945:1: ( rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1 )
-            // InternalRoom.g:7946:2: rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1
+            // InternalRoom.g:8144:1: ( rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1 )
+            // InternalRoom.g:8145:2: rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1
             {
             pushFollow(FOLLOW_3);
             rule__PortOperation__Group_3_1__0__Impl();
@@ -23308,17 +23876,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3_1__0__Impl"
-    // InternalRoom.g:7953:1: rule__PortOperation__Group_3_1__0__Impl : ( ',' ) ;
+    // InternalRoom.g:8152:1: rule__PortOperation__Group_3_1__0__Impl : ( ',' ) ;
     public final void rule__PortOperation__Group_3_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7957:1: ( ( ',' ) )
-            // InternalRoom.g:7958:1: ( ',' )
+            // InternalRoom.g:8156:1: ( ( ',' ) )
+            // InternalRoom.g:8157:1: ( ',' )
             {
-            // InternalRoom.g:7958:1: ( ',' )
-            // InternalRoom.g:7959:1: ','
+            // InternalRoom.g:8157:1: ( ',' )
+            // InternalRoom.g:8158:1: ','
             {
              before(grammarAccess.getPortOperationAccess().getCommaKeyword_3_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -23345,14 +23913,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3_1__1"
-    // InternalRoom.g:7972:1: rule__PortOperation__Group_3_1__1 : rule__PortOperation__Group_3_1__1__Impl ;
+    // InternalRoom.g:8171:1: rule__PortOperation__Group_3_1__1 : rule__PortOperation__Group_3_1__1__Impl ;
     public final void rule__PortOperation__Group_3_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7976:1: ( rule__PortOperation__Group_3_1__1__Impl )
-            // InternalRoom.g:7977:2: rule__PortOperation__Group_3_1__1__Impl
+            // InternalRoom.g:8175:1: ( rule__PortOperation__Group_3_1__1__Impl )
+            // InternalRoom.g:8176:2: rule__PortOperation__Group_3_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_3_1__1__Impl();
@@ -23378,21 +23946,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_3_1__1__Impl"
-    // InternalRoom.g:7983:1: rule__PortOperation__Group_3_1__1__Impl : ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) ) ;
+    // InternalRoom.g:8182:1: rule__PortOperation__Group_3_1__1__Impl : ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) ) ;
     public final void rule__PortOperation__Group_3_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:7987:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) ) )
-            // InternalRoom.g:7988:1: ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) )
+            // InternalRoom.g:8186:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) ) )
+            // InternalRoom.g:8187:1: ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) )
             {
-            // InternalRoom.g:7988:1: ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) )
-            // InternalRoom.g:7989:1: ( rule__PortOperation__ArgumentsAssignment_3_1_1 )
+            // InternalRoom.g:8187:1: ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) )
+            // InternalRoom.g:8188:1: ( rule__PortOperation__ArgumentsAssignment_3_1_1 )
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_1_1()); 
-            // InternalRoom.g:7990:1: ( rule__PortOperation__ArgumentsAssignment_3_1_1 )
-            // InternalRoom.g:7990:2: rule__PortOperation__ArgumentsAssignment_3_1_1
+            // InternalRoom.g:8189:1: ( rule__PortOperation__ArgumentsAssignment_3_1_1 )
+            // InternalRoom.g:8189:2: rule__PortOperation__ArgumentsAssignment_3_1_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__ArgumentsAssignment_3_1_1();
@@ -23425,14 +23993,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_0__0"
-    // InternalRoom.g:8004:1: rule__PortOperation__Group_5_0__0 : rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1 ;
+    // InternalRoom.g:8203:1: rule__PortOperation__Group_5_0__0 : rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1 ;
     public final void rule__PortOperation__Group_5_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8008:1: ( rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1 )
-            // InternalRoom.g:8009:2: rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1
+            // InternalRoom.g:8207:1: ( rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1 )
+            // InternalRoom.g:8208:2: rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1
             {
             pushFollow(FOLLOW_36);
             rule__PortOperation__Group_5_0__0__Impl();
@@ -23463,17 +24031,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_0__0__Impl"
-    // InternalRoom.g:8016:1: rule__PortOperation__Group_5_0__0__Impl : ( ':' ) ;
+    // InternalRoom.g:8215:1: rule__PortOperation__Group_5_0__0__Impl : ( ':' ) ;
     public final void rule__PortOperation__Group_5_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8020:1: ( ( ':' ) )
-            // InternalRoom.g:8021:1: ( ':' )
+            // InternalRoom.g:8219:1: ( ( ':' ) )
+            // InternalRoom.g:8220:1: ( ':' )
             {
-            // InternalRoom.g:8021:1: ( ':' )
-            // InternalRoom.g:8022:1: ':'
+            // InternalRoom.g:8220:1: ( ':' )
+            // InternalRoom.g:8221:1: ':'
             {
              before(grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0()); 
             match(input,46,FOLLOW_2); 
@@ -23500,14 +24068,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_0__1"
-    // InternalRoom.g:8035:1: rule__PortOperation__Group_5_0__1 : rule__PortOperation__Group_5_0__1__Impl ;
+    // InternalRoom.g:8234:1: rule__PortOperation__Group_5_0__1 : rule__PortOperation__Group_5_0__1__Impl ;
     public final void rule__PortOperation__Group_5_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8039:1: ( rule__PortOperation__Group_5_0__1__Impl )
-            // InternalRoom.g:8040:2: rule__PortOperation__Group_5_0__1__Impl
+            // InternalRoom.g:8238:1: ( rule__PortOperation__Group_5_0__1__Impl )
+            // InternalRoom.g:8239:2: rule__PortOperation__Group_5_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_5_0__1__Impl();
@@ -23533,21 +24101,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_0__1__Impl"
-    // InternalRoom.g:8046:1: rule__PortOperation__Group_5_0__1__Impl : ( ( rule__PortOperation__Alternatives_5_0_1 ) ) ;
+    // InternalRoom.g:8245:1: rule__PortOperation__Group_5_0__1__Impl : ( ( rule__PortOperation__Alternatives_5_0_1 ) ) ;
     public final void rule__PortOperation__Group_5_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8050:1: ( ( ( rule__PortOperation__Alternatives_5_0_1 ) ) )
-            // InternalRoom.g:8051:1: ( ( rule__PortOperation__Alternatives_5_0_1 ) )
+            // InternalRoom.g:8249:1: ( ( ( rule__PortOperation__Alternatives_5_0_1 ) ) )
+            // InternalRoom.g:8250:1: ( ( rule__PortOperation__Alternatives_5_0_1 ) )
             {
-            // InternalRoom.g:8051:1: ( ( rule__PortOperation__Alternatives_5_0_1 ) )
-            // InternalRoom.g:8052:1: ( rule__PortOperation__Alternatives_5_0_1 )
+            // InternalRoom.g:8250:1: ( ( rule__PortOperation__Alternatives_5_0_1 ) )
+            // InternalRoom.g:8251:1: ( rule__PortOperation__Alternatives_5_0_1 )
             {
              before(grammarAccess.getPortOperationAccess().getAlternatives_5_0_1()); 
-            // InternalRoom.g:8053:1: ( rule__PortOperation__Alternatives_5_0_1 )
-            // InternalRoom.g:8053:2: rule__PortOperation__Alternatives_5_0_1
+            // InternalRoom.g:8252:1: ( rule__PortOperation__Alternatives_5_0_1 )
+            // InternalRoom.g:8252:2: rule__PortOperation__Alternatives_5_0_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Alternatives_5_0_1();
@@ -23580,14 +24148,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_1__0"
-    // InternalRoom.g:8067:1: rule__PortOperation__Group_5_1__0 : rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1 ;
+    // InternalRoom.g:8266:1: rule__PortOperation__Group_5_1__0 : rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1 ;
     public final void rule__PortOperation__Group_5_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8071:1: ( rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1 )
-            // InternalRoom.g:8072:2: rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1
+            // InternalRoom.g:8270:1: ( rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1 )
+            // InternalRoom.g:8271:2: rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1
             {
             pushFollow(FOLLOW_3);
             rule__PortOperation__Group_5_1__0__Impl();
@@ -23618,17 +24186,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_1__0__Impl"
-    // InternalRoom.g:8079:1: rule__PortOperation__Group_5_1__0__Impl : ( 'sends' ) ;
+    // InternalRoom.g:8278:1: rule__PortOperation__Group_5_1__0__Impl : ( 'sends' ) ;
     public final void rule__PortOperation__Group_5_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8083:1: ( ( 'sends' ) )
-            // InternalRoom.g:8084:1: ( 'sends' )
+            // InternalRoom.g:8282:1: ( ( 'sends' ) )
+            // InternalRoom.g:8283:1: ( 'sends' )
             {
-            // InternalRoom.g:8084:1: ( 'sends' )
-            // InternalRoom.g:8085:1: 'sends'
+            // InternalRoom.g:8283:1: ( 'sends' )
+            // InternalRoom.g:8284:1: 'sends'
             {
              before(grammarAccess.getPortOperationAccess().getSendsKeyword_5_1_0()); 
             match(input,65,FOLLOW_2); 
@@ -23655,14 +24223,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_1__1"
-    // InternalRoom.g:8098:1: rule__PortOperation__Group_5_1__1 : rule__PortOperation__Group_5_1__1__Impl ;
+    // InternalRoom.g:8297:1: rule__PortOperation__Group_5_1__1 : rule__PortOperation__Group_5_1__1__Impl ;
     public final void rule__PortOperation__Group_5_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8102:1: ( rule__PortOperation__Group_5_1__1__Impl )
-            // InternalRoom.g:8103:2: rule__PortOperation__Group_5_1__1__Impl
+            // InternalRoom.g:8301:1: ( rule__PortOperation__Group_5_1__1__Impl )
+            // InternalRoom.g:8302:2: rule__PortOperation__Group_5_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_5_1__1__Impl();
@@ -23688,21 +24256,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group_5_1__1__Impl"
-    // InternalRoom.g:8109:1: rule__PortOperation__Group_5_1__1__Impl : ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) ) ;
+    // InternalRoom.g:8308:1: rule__PortOperation__Group_5_1__1__Impl : ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) ) ;
     public final void rule__PortOperation__Group_5_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8113:1: ( ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) ) )
-            // InternalRoom.g:8114:1: ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) )
+            // InternalRoom.g:8312:1: ( ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) ) )
+            // InternalRoom.g:8313:1: ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) )
             {
-            // InternalRoom.g:8114:1: ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) )
-            // InternalRoom.g:8115:1: ( rule__PortOperation__SendsMsgAssignment_5_1_1 )
+            // InternalRoom.g:8313:1: ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) )
+            // InternalRoom.g:8314:1: ( rule__PortOperation__SendsMsgAssignment_5_1_1 )
             {
              before(grammarAccess.getPortOperationAccess().getSendsMsgAssignment_5_1_1()); 
-            // InternalRoom.g:8116:1: ( rule__PortOperation__SendsMsgAssignment_5_1_1 )
-            // InternalRoom.g:8116:2: rule__PortOperation__SendsMsgAssignment_5_1_1
+            // InternalRoom.g:8315:1: ( rule__PortOperation__SendsMsgAssignment_5_1_1 )
+            // InternalRoom.g:8315:2: rule__PortOperation__SendsMsgAssignment_5_1_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__SendsMsgAssignment_5_1_1();
@@ -23735,14 +24303,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__Group__0"
-    // InternalRoom.g:8130:1: rule__ClassStructor__Group__0 : rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1 ;
+    // InternalRoom.g:8329:1: rule__ClassStructor__Group__0 : rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1 ;
     public final void rule__ClassStructor__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8134:1: ( rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1 )
-            // InternalRoom.g:8135:2: rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1
+            // InternalRoom.g:8333:1: ( rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1 )
+            // InternalRoom.g:8334:2: rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1
             {
             pushFollow(FOLLOW_27);
             rule__ClassStructor__Group__0__Impl();
@@ -23773,21 +24341,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__Group__0__Impl"
-    // InternalRoom.g:8142:1: rule__ClassStructor__Group__0__Impl : ( ( rule__ClassStructor__NameAssignment_0 ) ) ;
+    // InternalRoom.g:8341:1: rule__ClassStructor__Group__0__Impl : ( ( rule__ClassStructor__NameAssignment_0 ) ) ;
     public final void rule__ClassStructor__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8146:1: ( ( ( rule__ClassStructor__NameAssignment_0 ) ) )
-            // InternalRoom.g:8147:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
+            // InternalRoom.g:8345:1: ( ( ( rule__ClassStructor__NameAssignment_0 ) ) )
+            // InternalRoom.g:8346:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
             {
-            // InternalRoom.g:8147:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
-            // InternalRoom.g:8148:1: ( rule__ClassStructor__NameAssignment_0 )
+            // InternalRoom.g:8346:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
+            // InternalRoom.g:8347:1: ( rule__ClassStructor__NameAssignment_0 )
             {
              before(grammarAccess.getClassStructorAccess().getNameAssignment_0()); 
-            // InternalRoom.g:8149:1: ( rule__ClassStructor__NameAssignment_0 )
-            // InternalRoom.g:8149:2: rule__ClassStructor__NameAssignment_0
+            // InternalRoom.g:8348:1: ( rule__ClassStructor__NameAssignment_0 )
+            // InternalRoom.g:8348:2: rule__ClassStructor__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__NameAssignment_0();
@@ -23820,14 +24388,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__Group__1"
-    // InternalRoom.g:8159:1: rule__ClassStructor__Group__1 : rule__ClassStructor__Group__1__Impl ;
+    // InternalRoom.g:8358:1: rule__ClassStructor__Group__1 : rule__ClassStructor__Group__1__Impl ;
     public final void rule__ClassStructor__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8163:1: ( rule__ClassStructor__Group__1__Impl )
-            // InternalRoom.g:8164:2: rule__ClassStructor__Group__1__Impl
+            // InternalRoom.g:8362:1: ( rule__ClassStructor__Group__1__Impl )
+            // InternalRoom.g:8363:2: rule__ClassStructor__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__Group__1__Impl();
@@ -23853,21 +24421,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__Group__1__Impl"
-    // InternalRoom.g:8170:1: rule__ClassStructor__Group__1__Impl : ( ( rule__ClassStructor__DetailCodeAssignment_1 ) ) ;
+    // InternalRoom.g:8369:1: rule__ClassStructor__Group__1__Impl : ( ( rule__ClassStructor__DetailCodeAssignment_1 ) ) ;
     public final void rule__ClassStructor__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8174:1: ( ( ( rule__ClassStructor__DetailCodeAssignment_1 ) ) )
-            // InternalRoom.g:8175:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
+            // InternalRoom.g:8373:1: ( ( ( rule__ClassStructor__DetailCodeAssignment_1 ) ) )
+            // InternalRoom.g:8374:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
             {
-            // InternalRoom.g:8175:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
-            // InternalRoom.g:8176:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
+            // InternalRoom.g:8374:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
+            // InternalRoom.g:8375:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
             {
              before(grammarAccess.getClassStructorAccess().getDetailCodeAssignment_1()); 
-            // InternalRoom.g:8177:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
-            // InternalRoom.g:8177:2: rule__ClassStructor__DetailCodeAssignment_1
+            // InternalRoom.g:8376:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
+            // InternalRoom.g:8376:2: rule__ClassStructor__DetailCodeAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__DetailCodeAssignment_1();
@@ -23900,14 +24468,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__0"
-    // InternalRoom.g:8191:1: rule__ProtocolClass__Group__0 : rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1 ;
+    // InternalRoom.g:8390:1: rule__ProtocolClass__Group__0 : rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1 ;
     public final void rule__ProtocolClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8195:1: ( rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1 )
-            // InternalRoom.g:8196:2: rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1
+            // InternalRoom.g:8394:1: ( rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1 )
+            // InternalRoom.g:8395:2: rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1
             {
             pushFollow(FOLLOW_38);
             rule__ProtocolClass__Group__0__Impl();
@@ -23938,29 +24506,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__0__Impl"
-    // InternalRoom.g:8203:1: rule__ProtocolClass__Group__0__Impl : ( ( rule__ProtocolClass__CommTypeAssignment_0 )? ) ;
+    // InternalRoom.g:8402:1: rule__ProtocolClass__Group__0__Impl : ( ( rule__ProtocolClass__CommTypeAssignment_0 )? ) ;
     public final void rule__ProtocolClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8207:1: ( ( ( rule__ProtocolClass__CommTypeAssignment_0 )? ) )
-            // InternalRoom.g:8208:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
+            // InternalRoom.g:8406:1: ( ( ( rule__ProtocolClass__CommTypeAssignment_0 )? ) )
+            // InternalRoom.g:8407:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
             {
-            // InternalRoom.g:8208:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
-            // InternalRoom.g:8209:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
+            // InternalRoom.g:8407:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
+            // InternalRoom.g:8408:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getCommTypeAssignment_0()); 
-            // InternalRoom.g:8210:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
-            int alt88=2;
-            int LA88_0 = input.LA(1);
+            // InternalRoom.g:8409:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
+            int alt90=2;
+            int LA90_0 = input.LA(1);
 
-            if ( ((LA88_0>=33 && LA88_0<=35)) ) {
-                alt88=1;
+            if ( ((LA90_0>=33 && LA90_0<=35)) ) {
+                alt90=1;
             }
-            switch (alt88) {
+            switch (alt90) {
                 case 1 :
-                    // InternalRoom.g:8210:2: rule__ProtocolClass__CommTypeAssignment_0
+                    // InternalRoom.g:8409:2: rule__ProtocolClass__CommTypeAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__CommTypeAssignment_0();
@@ -23996,14 +24564,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__1"
-    // InternalRoom.g:8220:1: rule__ProtocolClass__Group__1 : rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2 ;
+    // InternalRoom.g:8419:1: rule__ProtocolClass__Group__1 : rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2 ;
     public final void rule__ProtocolClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8224:1: ( rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2 )
-            // InternalRoom.g:8225:2: rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2
+            // InternalRoom.g:8423:1: ( rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2 )
+            // InternalRoom.g:8424:2: rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ProtocolClass__Group__1__Impl();
@@ -24034,17 +24602,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__1__Impl"
-    // InternalRoom.g:8232:1: rule__ProtocolClass__Group__1__Impl : ( 'ProtocolClass' ) ;
+    // InternalRoom.g:8431:1: rule__ProtocolClass__Group__1__Impl : ( 'ProtocolClass' ) ;
     public final void rule__ProtocolClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8236:1: ( ( 'ProtocolClass' ) )
-            // InternalRoom.g:8237:1: ( 'ProtocolClass' )
+            // InternalRoom.g:8435:1: ( ( 'ProtocolClass' ) )
+            // InternalRoom.g:8436:1: ( 'ProtocolClass' )
             {
-            // InternalRoom.g:8237:1: ( 'ProtocolClass' )
-            // InternalRoom.g:8238:1: 'ProtocolClass'
+            // InternalRoom.g:8436:1: ( 'ProtocolClass' )
+            // InternalRoom.g:8437:1: 'ProtocolClass'
             {
              before(grammarAccess.getProtocolClassAccess().getProtocolClassKeyword_1()); 
             match(input,20,FOLLOW_2); 
@@ -24071,14 +24639,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__2"
-    // InternalRoom.g:8251:1: rule__ProtocolClass__Group__2 : rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3 ;
+    // InternalRoom.g:8450:1: rule__ProtocolClass__Group__2 : rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3 ;
     public final void rule__ProtocolClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8255:1: ( rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3 )
-            // InternalRoom.g:8256:2: rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3
+            // InternalRoom.g:8454:1: ( rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3 )
+            // InternalRoom.g:8455:2: rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__2__Impl();
@@ -24109,21 +24677,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__2__Impl"
-    // InternalRoom.g:8263:1: rule__ProtocolClass__Group__2__Impl : ( ( rule__ProtocolClass__NameAssignment_2 ) ) ;
+    // InternalRoom.g:8462:1: rule__ProtocolClass__Group__2__Impl : ( ( rule__ProtocolClass__NameAssignment_2 ) ) ;
     public final void rule__ProtocolClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8267:1: ( ( ( rule__ProtocolClass__NameAssignment_2 ) ) )
-            // InternalRoom.g:8268:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
+            // InternalRoom.g:8466:1: ( ( ( rule__ProtocolClass__NameAssignment_2 ) ) )
+            // InternalRoom.g:8467:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
             {
-            // InternalRoom.g:8268:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
-            // InternalRoom.g:8269:1: ( rule__ProtocolClass__NameAssignment_2 )
+            // InternalRoom.g:8467:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
+            // InternalRoom.g:8468:1: ( rule__ProtocolClass__NameAssignment_2 )
             {
              before(grammarAccess.getProtocolClassAccess().getNameAssignment_2()); 
-            // InternalRoom.g:8270:1: ( rule__ProtocolClass__NameAssignment_2 )
-            // InternalRoom.g:8270:2: rule__ProtocolClass__NameAssignment_2
+            // InternalRoom.g:8469:1: ( rule__ProtocolClass__NameAssignment_2 )
+            // InternalRoom.g:8469:2: rule__ProtocolClass__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__NameAssignment_2();
@@ -24156,14 +24724,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__3"
-    // InternalRoom.g:8280:1: rule__ProtocolClass__Group__3 : rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4 ;
+    // InternalRoom.g:8479:1: rule__ProtocolClass__Group__3 : rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4 ;
     public final void rule__ProtocolClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8284:1: ( rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4 )
-            // InternalRoom.g:8285:2: rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4
+            // InternalRoom.g:8483:1: ( rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4 )
+            // InternalRoom.g:8484:2: rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__3__Impl();
@@ -24194,29 +24762,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__3__Impl"
-    // InternalRoom.g:8292:1: rule__ProtocolClass__Group__3__Impl : ( ( rule__ProtocolClass__DocuAssignment_3 )? ) ;
+    // InternalRoom.g:8491:1: rule__ProtocolClass__Group__3__Impl : ( ( rule__ProtocolClass__DocuAssignment_3 )? ) ;
     public final void rule__ProtocolClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8296:1: ( ( ( rule__ProtocolClass__DocuAssignment_3 )? ) )
-            // InternalRoom.g:8297:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
+            // InternalRoom.g:8495:1: ( ( ( rule__ProtocolClass__DocuAssignment_3 )? ) )
+            // InternalRoom.g:8496:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
             {
-            // InternalRoom.g:8297:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
-            // InternalRoom.g:8298:1: ( rule__ProtocolClass__DocuAssignment_3 )?
+            // InternalRoom.g:8496:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
+            // InternalRoom.g:8497:1: ( rule__ProtocolClass__DocuAssignment_3 )?
             {
              before(grammarAccess.getProtocolClassAccess().getDocuAssignment_3()); 
-            // InternalRoom.g:8299:1: ( rule__ProtocolClass__DocuAssignment_3 )?
-            int alt89=2;
-            int LA89_0 = input.LA(1);
+            // InternalRoom.g:8498:1: ( rule__ProtocolClass__DocuAssignment_3 )?
+            int alt91=2;
+            int LA91_0 = input.LA(1);
 
-            if ( (LA89_0==62) ) {
-                alt89=1;
+            if ( (LA91_0==62) ) {
+                alt91=1;
             }
-            switch (alt89) {
+            switch (alt91) {
                 case 1 :
-                    // InternalRoom.g:8299:2: rule__ProtocolClass__DocuAssignment_3
+                    // InternalRoom.g:8498:2: rule__ProtocolClass__DocuAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__DocuAssignment_3();
@@ -24252,14 +24820,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__4"
-    // InternalRoom.g:8309:1: rule__ProtocolClass__Group__4 : rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5 ;
+    // InternalRoom.g:8508:1: rule__ProtocolClass__Group__4 : rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5 ;
     public final void rule__ProtocolClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8313:1: ( rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5 )
-            // InternalRoom.g:8314:2: rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5
+            // InternalRoom.g:8512:1: ( rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5 )
+            // InternalRoom.g:8513:2: rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__4__Impl();
@@ -24290,29 +24858,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__4__Impl"
-    // InternalRoom.g:8321:1: rule__ProtocolClass__Group__4__Impl : ( ( rule__ProtocolClass__Group_4__0 )? ) ;
+    // InternalRoom.g:8520:1: rule__ProtocolClass__Group__4__Impl : ( ( rule__ProtocolClass__Group_4__0 )? ) ;
     public final void rule__ProtocolClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8325:1: ( ( ( rule__ProtocolClass__Group_4__0 )? ) )
-            // InternalRoom.g:8326:1: ( ( rule__ProtocolClass__Group_4__0 )? )
+            // InternalRoom.g:8524:1: ( ( ( rule__ProtocolClass__Group_4__0 )? ) )
+            // InternalRoom.g:8525:1: ( ( rule__ProtocolClass__Group_4__0 )? )
             {
-            // InternalRoom.g:8326:1: ( ( rule__ProtocolClass__Group_4__0 )? )
-            // InternalRoom.g:8327:1: ( rule__ProtocolClass__Group_4__0 )?
+            // InternalRoom.g:8525:1: ( ( rule__ProtocolClass__Group_4__0 )? )
+            // InternalRoom.g:8526:1: ( rule__ProtocolClass__Group_4__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_4()); 
-            // InternalRoom.g:8328:1: ( rule__ProtocolClass__Group_4__0 )?
-            int alt90=2;
-            int LA90_0 = input.LA(1);
+            // InternalRoom.g:8527:1: ( rule__ProtocolClass__Group_4__0 )?
+            int alt92=2;
+            int LA92_0 = input.LA(1);
 
-            if ( (LA90_0==57) ) {
-                alt90=1;
+            if ( (LA92_0==57) ) {
+                alt92=1;
             }
-            switch (alt90) {
+            switch (alt92) {
                 case 1 :
-                    // InternalRoom.g:8328:2: rule__ProtocolClass__Group_4__0
+                    // InternalRoom.g:8527:2: rule__ProtocolClass__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_4__0();
@@ -24348,14 +24916,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__5"
-    // InternalRoom.g:8338:1: rule__ProtocolClass__Group__5 : rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6 ;
+    // InternalRoom.g:8537:1: rule__ProtocolClass__Group__5 : rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6 ;
     public final void rule__ProtocolClass__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8342:1: ( rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6 )
-            // InternalRoom.g:8343:2: rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6
+            // InternalRoom.g:8541:1: ( rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6 )
+            // InternalRoom.g:8542:2: rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__5__Impl();
@@ -24386,17 +24954,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__5__Impl"
-    // InternalRoom.g:8350:1: rule__ProtocolClass__Group__5__Impl : ( '{' ) ;
+    // InternalRoom.g:8549:1: rule__ProtocolClass__Group__5__Impl : ( '{' ) ;
     public final void rule__ProtocolClass__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8354:1: ( ( '{' ) )
-            // InternalRoom.g:8355:1: ( '{' )
+            // InternalRoom.g:8553:1: ( ( '{' ) )
+            // InternalRoom.g:8554:1: ( '{' )
             {
-            // InternalRoom.g:8355:1: ( '{' )
-            // InternalRoom.g:8356:1: '{'
+            // InternalRoom.g:8554:1: ( '{' )
+            // InternalRoom.g:8555:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_5()); 
             match(input,44,FOLLOW_2); 
@@ -24423,14 +24991,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__6"
-    // InternalRoom.g:8369:1: rule__ProtocolClass__Group__6 : rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7 ;
+    // InternalRoom.g:8568:1: rule__ProtocolClass__Group__6 : rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7 ;
     public final void rule__ProtocolClass__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8373:1: ( rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7 )
-            // InternalRoom.g:8374:2: rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7
+            // InternalRoom.g:8572:1: ( rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7 )
+            // InternalRoom.g:8573:2: rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__6__Impl();
@@ -24461,33 +25029,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__6__Impl"
-    // InternalRoom.g:8381:1: rule__ProtocolClass__Group__6__Impl : ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* ) ;
+    // InternalRoom.g:8580:1: rule__ProtocolClass__Group__6__Impl : ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* ) ;
     public final void rule__ProtocolClass__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8385:1: ( ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* ) )
-            // InternalRoom.g:8386:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:8584:1: ( ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:8585:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:8386:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:8387:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
+            // InternalRoom.g:8585:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:8586:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getProtocolClassAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:8388:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
-            loop91:
+            // InternalRoom.g:8587:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
+            loop93:
             do {
-                int alt91=2;
-                int LA91_0 = input.LA(1);
+                int alt93=2;
+                int LA93_0 = input.LA(1);
 
-                if ( (LA91_0==121) ) {
-                    alt91=1;
+                if ( (LA93_0==121) ) {
+                    alt93=1;
                 }
 
 
-                switch (alt91) {
+                switch (alt93) {
             	case 1 :
-            	    // InternalRoom.g:8388:2: rule__ProtocolClass__AnnotationsAssignment_6
+            	    // InternalRoom.g:8587:2: rule__ProtocolClass__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ProtocolClass__AnnotationsAssignment_6();
@@ -24499,7 +25067,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop91;
+            	    break loop93;
                 }
             } while (true);
 
@@ -24526,14 +25094,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__7"
-    // InternalRoom.g:8398:1: rule__ProtocolClass__Group__7 : rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8 ;
+    // InternalRoom.g:8597:1: rule__ProtocolClass__Group__7 : rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8 ;
     public final void rule__ProtocolClass__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8402:1: ( rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8 )
-            // InternalRoom.g:8403:2: rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8
+            // InternalRoom.g:8601:1: ( rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8 )
+            // InternalRoom.g:8602:2: rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__7__Impl();
@@ -24564,29 +25132,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__7__Impl"
-    // InternalRoom.g:8410:1: rule__ProtocolClass__Group__7__Impl : ( ( rule__ProtocolClass__Group_7__0 )? ) ;
+    // InternalRoom.g:8609:1: rule__ProtocolClass__Group__7__Impl : ( ( rule__ProtocolClass__Group_7__0 )? ) ;
     public final void rule__ProtocolClass__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8414:1: ( ( ( rule__ProtocolClass__Group_7__0 )? ) )
-            // InternalRoom.g:8415:1: ( ( rule__ProtocolClass__Group_7__0 )? )
+            // InternalRoom.g:8613:1: ( ( ( rule__ProtocolClass__Group_7__0 )? ) )
+            // InternalRoom.g:8614:1: ( ( rule__ProtocolClass__Group_7__0 )? )
             {
-            // InternalRoom.g:8415:1: ( ( rule__ProtocolClass__Group_7__0 )? )
-            // InternalRoom.g:8416:1: ( rule__ProtocolClass__Group_7__0 )?
+            // InternalRoom.g:8614:1: ( ( rule__ProtocolClass__Group_7__0 )? )
+            // InternalRoom.g:8615:1: ( rule__ProtocolClass__Group_7__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_7()); 
-            // InternalRoom.g:8417:1: ( rule__ProtocolClass__Group_7__0 )?
-            int alt92=2;
-            int LA92_0 = input.LA(1);
+            // InternalRoom.g:8616:1: ( rule__ProtocolClass__Group_7__0 )?
+            int alt94=2;
+            int LA94_0 = input.LA(1);
 
-            if ( (LA92_0==58) ) {
-                alt92=1;
+            if ( (LA94_0==58) ) {
+                alt94=1;
             }
-            switch (alt92) {
+            switch (alt94) {
                 case 1 :
-                    // InternalRoom.g:8417:2: rule__ProtocolClass__Group_7__0
+                    // InternalRoom.g:8616:2: rule__ProtocolClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_7__0();
@@ -24622,14 +25190,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__8"
-    // InternalRoom.g:8427:1: rule__ProtocolClass__Group__8 : rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9 ;
+    // InternalRoom.g:8626:1: rule__ProtocolClass__Group__8 : rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9 ;
     public final void rule__ProtocolClass__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8431:1: ( rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9 )
-            // InternalRoom.g:8432:2: rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9
+            // InternalRoom.g:8630:1: ( rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9 )
+            // InternalRoom.g:8631:2: rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__8__Impl();
@@ -24660,29 +25228,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__8__Impl"
-    // InternalRoom.g:8439:1: rule__ProtocolClass__Group__8__Impl : ( ( rule__ProtocolClass__Group_8__0 )? ) ;
+    // InternalRoom.g:8638:1: rule__ProtocolClass__Group__8__Impl : ( ( rule__ProtocolClass__Group_8__0 )? ) ;
     public final void rule__ProtocolClass__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8443:1: ( ( ( rule__ProtocolClass__Group_8__0 )? ) )
-            // InternalRoom.g:8444:1: ( ( rule__ProtocolClass__Group_8__0 )? )
+            // InternalRoom.g:8642:1: ( ( ( rule__ProtocolClass__Group_8__0 )? ) )
+            // InternalRoom.g:8643:1: ( ( rule__ProtocolClass__Group_8__0 )? )
             {
-            // InternalRoom.g:8444:1: ( ( rule__ProtocolClass__Group_8__0 )? )
-            // InternalRoom.g:8445:1: ( rule__ProtocolClass__Group_8__0 )?
+            // InternalRoom.g:8643:1: ( ( rule__ProtocolClass__Group_8__0 )? )
+            // InternalRoom.g:8644:1: ( rule__ProtocolClass__Group_8__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_8()); 
-            // InternalRoom.g:8446:1: ( rule__ProtocolClass__Group_8__0 )?
-            int alt93=2;
-            int LA93_0 = input.LA(1);
+            // InternalRoom.g:8645:1: ( rule__ProtocolClass__Group_8__0 )?
+            int alt95=2;
+            int LA95_0 = input.LA(1);
 
-            if ( (LA93_0==59) ) {
-                alt93=1;
+            if ( (LA95_0==59) ) {
+                alt95=1;
             }
-            switch (alt93) {
+            switch (alt95) {
                 case 1 :
-                    // InternalRoom.g:8446:2: rule__ProtocolClass__Group_8__0
+                    // InternalRoom.g:8645:2: rule__ProtocolClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_8__0();
@@ -24718,14 +25286,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__9"
-    // InternalRoom.g:8456:1: rule__ProtocolClass__Group__9 : rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10 ;
+    // InternalRoom.g:8655:1: rule__ProtocolClass__Group__9 : rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10 ;
     public final void rule__ProtocolClass__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8460:1: ( rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10 )
-            // InternalRoom.g:8461:2: rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10
+            // InternalRoom.g:8659:1: ( rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10 )
+            // InternalRoom.g:8660:2: rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__9__Impl();
@@ -24756,29 +25324,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__9__Impl"
-    // InternalRoom.g:8468:1: rule__ProtocolClass__Group__9__Impl : ( ( rule__ProtocolClass__Group_9__0 )? ) ;
+    // InternalRoom.g:8667:1: rule__ProtocolClass__Group__9__Impl : ( ( rule__ProtocolClass__Group_9__0 )? ) ;
     public final void rule__ProtocolClass__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8472:1: ( ( ( rule__ProtocolClass__Group_9__0 )? ) )
-            // InternalRoom.g:8473:1: ( ( rule__ProtocolClass__Group_9__0 )? )
+            // InternalRoom.g:8671:1: ( ( ( rule__ProtocolClass__Group_9__0 )? ) )
+            // InternalRoom.g:8672:1: ( ( rule__ProtocolClass__Group_9__0 )? )
             {
-            // InternalRoom.g:8473:1: ( ( rule__ProtocolClass__Group_9__0 )? )
-            // InternalRoom.g:8474:1: ( rule__ProtocolClass__Group_9__0 )?
+            // InternalRoom.g:8672:1: ( ( rule__ProtocolClass__Group_9__0 )? )
+            // InternalRoom.g:8673:1: ( rule__ProtocolClass__Group_9__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_9()); 
-            // InternalRoom.g:8475:1: ( rule__ProtocolClass__Group_9__0 )?
-            int alt94=2;
-            int LA94_0 = input.LA(1);
+            // InternalRoom.g:8674:1: ( rule__ProtocolClass__Group_9__0 )?
+            int alt96=2;
+            int LA96_0 = input.LA(1);
 
-            if ( (LA94_0==60) ) {
-                alt94=1;
+            if ( (LA96_0==60) ) {
+                alt96=1;
             }
-            switch (alt94) {
+            switch (alt96) {
                 case 1 :
-                    // InternalRoom.g:8475:2: rule__ProtocolClass__Group_9__0
+                    // InternalRoom.g:8674:2: rule__ProtocolClass__Group_9__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_9__0();
@@ -24814,14 +25382,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__10"
-    // InternalRoom.g:8485:1: rule__ProtocolClass__Group__10 : rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11 ;
+    // InternalRoom.g:8684:1: rule__ProtocolClass__Group__10 : rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11 ;
     public final void rule__ProtocolClass__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8489:1: ( rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11 )
-            // InternalRoom.g:8490:2: rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11
+            // InternalRoom.g:8688:1: ( rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11 )
+            // InternalRoom.g:8689:2: rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__10__Impl();
@@ -24852,29 +25420,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__10__Impl"
-    // InternalRoom.g:8497:1: rule__ProtocolClass__Group__10__Impl : ( ( rule__ProtocolClass__Group_10__0 )? ) ;
+    // InternalRoom.g:8696:1: rule__ProtocolClass__Group__10__Impl : ( ( rule__ProtocolClass__Group_10__0 )? ) ;
     public final void rule__ProtocolClass__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8501:1: ( ( ( rule__ProtocolClass__Group_10__0 )? ) )
-            // InternalRoom.g:8502:1: ( ( rule__ProtocolClass__Group_10__0 )? )
+            // InternalRoom.g:8700:1: ( ( ( rule__ProtocolClass__Group_10__0 )? ) )
+            // InternalRoom.g:8701:1: ( ( rule__ProtocolClass__Group_10__0 )? )
             {
-            // InternalRoom.g:8502:1: ( ( rule__ProtocolClass__Group_10__0 )? )
-            // InternalRoom.g:8503:1: ( rule__ProtocolClass__Group_10__0 )?
+            // InternalRoom.g:8701:1: ( ( rule__ProtocolClass__Group_10__0 )? )
+            // InternalRoom.g:8702:1: ( rule__ProtocolClass__Group_10__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_10()); 
-            // InternalRoom.g:8504:1: ( rule__ProtocolClass__Group_10__0 )?
-            int alt95=2;
-            int LA95_0 = input.LA(1);
+            // InternalRoom.g:8703:1: ( rule__ProtocolClass__Group_10__0 )?
+            int alt97=2;
+            int LA97_0 = input.LA(1);
 
-            if ( (LA95_0==66) ) {
-                alt95=1;
+            if ( (LA97_0==66) ) {
+                alt97=1;
             }
-            switch (alt95) {
+            switch (alt97) {
                 case 1 :
-                    // InternalRoom.g:8504:2: rule__ProtocolClass__Group_10__0
+                    // InternalRoom.g:8703:2: rule__ProtocolClass__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_10__0();
@@ -24910,14 +25478,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__11"
-    // InternalRoom.g:8514:1: rule__ProtocolClass__Group__11 : rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12 ;
+    // InternalRoom.g:8713:1: rule__ProtocolClass__Group__11 : rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12 ;
     public final void rule__ProtocolClass__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8518:1: ( rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12 )
-            // InternalRoom.g:8519:2: rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12
+            // InternalRoom.g:8717:1: ( rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12 )
+            // InternalRoom.g:8718:2: rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__11__Impl();
@@ -24948,29 +25516,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__11__Impl"
-    // InternalRoom.g:8526:1: rule__ProtocolClass__Group__11__Impl : ( ( rule__ProtocolClass__Group_11__0 )? ) ;
+    // InternalRoom.g:8725:1: rule__ProtocolClass__Group__11__Impl : ( ( rule__ProtocolClass__Group_11__0 )? ) ;
     public final void rule__ProtocolClass__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8530:1: ( ( ( rule__ProtocolClass__Group_11__0 )? ) )
-            // InternalRoom.g:8531:1: ( ( rule__ProtocolClass__Group_11__0 )? )
+            // InternalRoom.g:8729:1: ( ( ( rule__ProtocolClass__Group_11__0 )? ) )
+            // InternalRoom.g:8730:1: ( ( rule__ProtocolClass__Group_11__0 )? )
             {
-            // InternalRoom.g:8531:1: ( ( rule__ProtocolClass__Group_11__0 )? )
-            // InternalRoom.g:8532:1: ( rule__ProtocolClass__Group_11__0 )?
+            // InternalRoom.g:8730:1: ( ( rule__ProtocolClass__Group_11__0 )? )
+            // InternalRoom.g:8731:1: ( rule__ProtocolClass__Group_11__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_11()); 
-            // InternalRoom.g:8533:1: ( rule__ProtocolClass__Group_11__0 )?
-            int alt96=2;
-            int LA96_0 = input.LA(1);
+            // InternalRoom.g:8732:1: ( rule__ProtocolClass__Group_11__0 )?
+            int alt98=2;
+            int LA98_0 = input.LA(1);
 
-            if ( (LA96_0==67) ) {
-                alt96=1;
+            if ( (LA98_0==67) ) {
+                alt98=1;
             }
-            switch (alt96) {
+            switch (alt98) {
                 case 1 :
-                    // InternalRoom.g:8533:2: rule__ProtocolClass__Group_11__0
+                    // InternalRoom.g:8732:2: rule__ProtocolClass__Group_11__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_11__0();
@@ -25006,14 +25574,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__12"
-    // InternalRoom.g:8543:1: rule__ProtocolClass__Group__12 : rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13 ;
+    // InternalRoom.g:8742:1: rule__ProtocolClass__Group__12 : rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13 ;
     public final void rule__ProtocolClass__Group__12() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8547:1: ( rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13 )
-            // InternalRoom.g:8548:2: rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13
+            // InternalRoom.g:8746:1: ( rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13 )
+            // InternalRoom.g:8747:2: rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__12__Impl();
@@ -25044,29 +25612,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__12__Impl"
-    // InternalRoom.g:8555:1: rule__ProtocolClass__Group__12__Impl : ( ( rule__ProtocolClass__Group_12__0 )? ) ;
+    // InternalRoom.g:8754:1: rule__ProtocolClass__Group__12__Impl : ( ( rule__ProtocolClass__Group_12__0 )? ) ;
     public final void rule__ProtocolClass__Group__12__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8559:1: ( ( ( rule__ProtocolClass__Group_12__0 )? ) )
-            // InternalRoom.g:8560:1: ( ( rule__ProtocolClass__Group_12__0 )? )
+            // InternalRoom.g:8758:1: ( ( ( rule__ProtocolClass__Group_12__0 )? ) )
+            // InternalRoom.g:8759:1: ( ( rule__ProtocolClass__Group_12__0 )? )
             {
-            // InternalRoom.g:8560:1: ( ( rule__ProtocolClass__Group_12__0 )? )
-            // InternalRoom.g:8561:1: ( rule__ProtocolClass__Group_12__0 )?
+            // InternalRoom.g:8759:1: ( ( rule__ProtocolClass__Group_12__0 )? )
+            // InternalRoom.g:8760:1: ( rule__ProtocolClass__Group_12__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_12()); 
-            // InternalRoom.g:8562:1: ( rule__ProtocolClass__Group_12__0 )?
-            int alt97=2;
-            int LA97_0 = input.LA(1);
+            // InternalRoom.g:8761:1: ( rule__ProtocolClass__Group_12__0 )?
+            int alt99=2;
+            int LA99_0 = input.LA(1);
 
-            if ( (LA97_0==68) ) {
-                alt97=1;
+            if ( (LA99_0==68) ) {
+                alt99=1;
             }
-            switch (alt97) {
+            switch (alt99) {
                 case 1 :
-                    // InternalRoom.g:8562:2: rule__ProtocolClass__Group_12__0
+                    // InternalRoom.g:8761:2: rule__ProtocolClass__Group_12__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_12__0();
@@ -25102,14 +25670,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__13"
-    // InternalRoom.g:8572:1: rule__ProtocolClass__Group__13 : rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14 ;
+    // InternalRoom.g:8771:1: rule__ProtocolClass__Group__13 : rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14 ;
     public final void rule__ProtocolClass__Group__13() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8576:1: ( rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14 )
-            // InternalRoom.g:8577:2: rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14
+            // InternalRoom.g:8775:1: ( rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14 )
+            // InternalRoom.g:8776:2: rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__13__Impl();
@@ -25140,29 +25708,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__13__Impl"
-    // InternalRoom.g:8584:1: rule__ProtocolClass__Group__13__Impl : ( ( rule__ProtocolClass__Group_13__0 )? ) ;
+    // InternalRoom.g:8783:1: rule__ProtocolClass__Group__13__Impl : ( ( rule__ProtocolClass__Group_13__0 )? ) ;
     public final void rule__ProtocolClass__Group__13__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8588:1: ( ( ( rule__ProtocolClass__Group_13__0 )? ) )
-            // InternalRoom.g:8589:1: ( ( rule__ProtocolClass__Group_13__0 )? )
+            // InternalRoom.g:8787:1: ( ( ( rule__ProtocolClass__Group_13__0 )? ) )
+            // InternalRoom.g:8788:1: ( ( rule__ProtocolClass__Group_13__0 )? )
             {
-            // InternalRoom.g:8589:1: ( ( rule__ProtocolClass__Group_13__0 )? )
-            // InternalRoom.g:8590:1: ( rule__ProtocolClass__Group_13__0 )?
+            // InternalRoom.g:8788:1: ( ( rule__ProtocolClass__Group_13__0 )? )
+            // InternalRoom.g:8789:1: ( rule__ProtocolClass__Group_13__0 )?
             {
              before(grammarAccess.getProtocolClassAccess().getGroup_13()); 
-            // InternalRoom.g:8591:1: ( rule__ProtocolClass__Group_13__0 )?
-            int alt98=2;
-            int LA98_0 = input.LA(1);
+            // InternalRoom.g:8790:1: ( rule__ProtocolClass__Group_13__0 )?
+            int alt100=2;
+            int LA100_0 = input.LA(1);
 
-            if ( (LA98_0==70) ) {
-                alt98=1;
+            if ( (LA100_0==70) ) {
+                alt100=1;
             }
-            switch (alt98) {
+            switch (alt100) {
                 case 1 :
-                    // InternalRoom.g:8591:2: rule__ProtocolClass__Group_13__0
+                    // InternalRoom.g:8790:2: rule__ProtocolClass__Group_13__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_13__0();
@@ -25198,14 +25766,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__14"
-    // InternalRoom.g:8601:1: rule__ProtocolClass__Group__14 : rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15 ;
+    // InternalRoom.g:8800:1: rule__ProtocolClass__Group__14 : rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15 ;
     public final void rule__ProtocolClass__Group__14() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8605:1: ( rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15 )
-            // InternalRoom.g:8606:2: rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15
+            // InternalRoom.g:8804:1: ( rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15 )
+            // InternalRoom.g:8805:2: rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__14__Impl();
@@ -25236,29 +25804,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__14__Impl"
-    // InternalRoom.g:8613:1: rule__ProtocolClass__Group__14__Impl : ( ( rule__ProtocolClass__SemanticsAssignment_14 )? ) ;
+    // InternalRoom.g:8812:1: rule__ProtocolClass__Group__14__Impl : ( ( rule__ProtocolClass__SemanticsAssignment_14 )? ) ;
     public final void rule__ProtocolClass__Group__14__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8617:1: ( ( ( rule__ProtocolClass__SemanticsAssignment_14 )? ) )
-            // InternalRoom.g:8618:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
+            // InternalRoom.g:8816:1: ( ( ( rule__ProtocolClass__SemanticsAssignment_14 )? ) )
+            // InternalRoom.g:8817:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
             {
-            // InternalRoom.g:8618:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
-            // InternalRoom.g:8619:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
+            // InternalRoom.g:8817:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
+            // InternalRoom.g:8818:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
             {
              before(grammarAccess.getProtocolClassAccess().getSemanticsAssignment_14()); 
-            // InternalRoom.g:8620:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
-            int alt99=2;
-            int LA99_0 = input.LA(1);
+            // InternalRoom.g:8819:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
+            int alt101=2;
+            int LA101_0 = input.LA(1);
 
-            if ( (LA99_0==118) ) {
-                alt99=1;
+            if ( (LA101_0==118) ) {
+                alt101=1;
             }
-            switch (alt99) {
+            switch (alt101) {
                 case 1 :
-                    // InternalRoom.g:8620:2: rule__ProtocolClass__SemanticsAssignment_14
+                    // InternalRoom.g:8819:2: rule__ProtocolClass__SemanticsAssignment_14
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__SemanticsAssignment_14();
@@ -25294,14 +25862,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__15"
-    // InternalRoom.g:8630:1: rule__ProtocolClass__Group__15 : rule__ProtocolClass__Group__15__Impl ;
+    // InternalRoom.g:8829:1: rule__ProtocolClass__Group__15 : rule__ProtocolClass__Group__15__Impl ;
     public final void rule__ProtocolClass__Group__15() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8634:1: ( rule__ProtocolClass__Group__15__Impl )
-            // InternalRoom.g:8635:2: rule__ProtocolClass__Group__15__Impl
+            // InternalRoom.g:8833:1: ( rule__ProtocolClass__Group__15__Impl )
+            // InternalRoom.g:8834:2: rule__ProtocolClass__Group__15__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group__15__Impl();
@@ -25327,17 +25895,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__15__Impl"
-    // InternalRoom.g:8641:1: rule__ProtocolClass__Group__15__Impl : ( '}' ) ;
+    // InternalRoom.g:8840:1: rule__ProtocolClass__Group__15__Impl : ( '}' ) ;
     public final void rule__ProtocolClass__Group__15__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8645:1: ( ( '}' ) )
-            // InternalRoom.g:8646:1: ( '}' )
+            // InternalRoom.g:8844:1: ( ( '}' ) )
+            // InternalRoom.g:8845:1: ( '}' )
             {
-            // InternalRoom.g:8646:1: ( '}' )
-            // InternalRoom.g:8647:1: '}'
+            // InternalRoom.g:8845:1: ( '}' )
+            // InternalRoom.g:8846:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_15()); 
             match(input,45,FOLLOW_2); 
@@ -25364,14 +25932,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_4__0"
-    // InternalRoom.g:8692:1: rule__ProtocolClass__Group_4__0 : rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1 ;
+    // InternalRoom.g:8891:1: rule__ProtocolClass__Group_4__0 : rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1 ;
     public final void rule__ProtocolClass__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8696:1: ( rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1 )
-            // InternalRoom.g:8697:2: rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1
+            // InternalRoom.g:8895:1: ( rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1 )
+            // InternalRoom.g:8896:2: rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1
             {
             pushFollow(FOLLOW_3);
             rule__ProtocolClass__Group_4__0__Impl();
@@ -25402,17 +25970,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_4__0__Impl"
-    // InternalRoom.g:8704:1: rule__ProtocolClass__Group_4__0__Impl : ( 'extends' ) ;
+    // InternalRoom.g:8903:1: rule__ProtocolClass__Group_4__0__Impl : ( 'extends' ) ;
     public final void rule__ProtocolClass__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8708:1: ( ( 'extends' ) )
-            // InternalRoom.g:8709:1: ( 'extends' )
+            // InternalRoom.g:8907:1: ( ( 'extends' ) )
+            // InternalRoom.g:8908:1: ( 'extends' )
             {
-            // InternalRoom.g:8709:1: ( 'extends' )
-            // InternalRoom.g:8710:1: 'extends'
+            // InternalRoom.g:8908:1: ( 'extends' )
+            // InternalRoom.g:8909:1: 'extends'
             {
              before(grammarAccess.getProtocolClassAccess().getExtendsKeyword_4_0()); 
             match(input,57,FOLLOW_2); 
@@ -25439,14 +26007,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_4__1"
-    // InternalRoom.g:8723:1: rule__ProtocolClass__Group_4__1 : rule__ProtocolClass__Group_4__1__Impl ;
+    // InternalRoom.g:8922:1: rule__ProtocolClass__Group_4__1 : rule__ProtocolClass__Group_4__1__Impl ;
     public final void rule__ProtocolClass__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8727:1: ( rule__ProtocolClass__Group_4__1__Impl )
-            // InternalRoom.g:8728:2: rule__ProtocolClass__Group_4__1__Impl
+            // InternalRoom.g:8926:1: ( rule__ProtocolClass__Group_4__1__Impl )
+            // InternalRoom.g:8927:2: rule__ProtocolClass__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_4__1__Impl();
@@ -25472,21 +26040,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_4__1__Impl"
-    // InternalRoom.g:8734:1: rule__ProtocolClass__Group_4__1__Impl : ( ( rule__ProtocolClass__BaseAssignment_4_1 ) ) ;
+    // InternalRoom.g:8933:1: rule__ProtocolClass__Group_4__1__Impl : ( ( rule__ProtocolClass__BaseAssignment_4_1 ) ) ;
     public final void rule__ProtocolClass__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8738:1: ( ( ( rule__ProtocolClass__BaseAssignment_4_1 ) ) )
-            // InternalRoom.g:8739:1: ( ( rule__ProtocolClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:8937:1: ( ( ( rule__ProtocolClass__BaseAssignment_4_1 ) ) )
+            // InternalRoom.g:8938:1: ( ( rule__ProtocolClass__BaseAssignment_4_1 ) )
             {
-            // InternalRoom.g:8739:1: ( ( rule__ProtocolClass__BaseAssignment_4_1 ) )
-            // InternalRoom.g:8740:1: ( rule__ProtocolClass__BaseAssignment_4_1 )
+            // InternalRoom.g:8938:1: ( ( rule__ProtocolClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:8939:1: ( rule__ProtocolClass__BaseAssignment_4_1 )
             {
              before(grammarAccess.getProtocolClassAccess().getBaseAssignment_4_1()); 
-            // InternalRoom.g:8741:1: ( rule__ProtocolClass__BaseAssignment_4_1 )
-            // InternalRoom.g:8741:2: rule__ProtocolClass__BaseAssignment_4_1
+            // InternalRoom.g:8940:1: ( rule__ProtocolClass__BaseAssignment_4_1 )
+            // InternalRoom.g:8940:2: rule__ProtocolClass__BaseAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__BaseAssignment_4_1();
@@ -25519,14 +26087,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_7__0"
-    // InternalRoom.g:8755:1: rule__ProtocolClass__Group_7__0 : rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1 ;
+    // InternalRoom.g:8954:1: rule__ProtocolClass__Group_7__0 : rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1 ;
     public final void rule__ProtocolClass__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8759:1: ( rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1 )
-            // InternalRoom.g:8760:2: rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1
+            // InternalRoom.g:8958:1: ( rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1 )
+            // InternalRoom.g:8959:2: rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_7__0__Impl();
@@ -25557,17 +26125,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_7__0__Impl"
-    // InternalRoom.g:8767:1: rule__ProtocolClass__Group_7__0__Impl : ( 'usercode1' ) ;
+    // InternalRoom.g:8966:1: rule__ProtocolClass__Group_7__0__Impl : ( 'usercode1' ) ;
     public final void rule__ProtocolClass__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8771:1: ( ( 'usercode1' ) )
-            // InternalRoom.g:8772:1: ( 'usercode1' )
+            // InternalRoom.g:8970:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:8971:1: ( 'usercode1' )
             {
-            // InternalRoom.g:8772:1: ( 'usercode1' )
-            // InternalRoom.g:8773:1: 'usercode1'
+            // InternalRoom.g:8971:1: ( 'usercode1' )
+            // InternalRoom.g:8972:1: 'usercode1'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode1Keyword_7_0()); 
             match(input,58,FOLLOW_2); 
@@ -25594,14 +26162,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_7__1"
-    // InternalRoom.g:8786:1: rule__ProtocolClass__Group_7__1 : rule__ProtocolClass__Group_7__1__Impl ;
+    // InternalRoom.g:8985:1: rule__ProtocolClass__Group_7__1 : rule__ProtocolClass__Group_7__1__Impl ;
     public final void rule__ProtocolClass__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8790:1: ( rule__ProtocolClass__Group_7__1__Impl )
-            // InternalRoom.g:8791:2: rule__ProtocolClass__Group_7__1__Impl
+            // InternalRoom.g:8989:1: ( rule__ProtocolClass__Group_7__1__Impl )
+            // InternalRoom.g:8990:2: rule__ProtocolClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_7__1__Impl();
@@ -25627,21 +26195,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_7__1__Impl"
-    // InternalRoom.g:8797:1: rule__ProtocolClass__Group_7__1__Impl : ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) ) ;
+    // InternalRoom.g:8996:1: rule__ProtocolClass__Group_7__1__Impl : ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) ) ;
     public final void rule__ProtocolClass__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8801:1: ( ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) ) )
-            // InternalRoom.g:8802:1: ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) )
+            // InternalRoom.g:9000:1: ( ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) ) )
+            // InternalRoom.g:9001:1: ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) )
             {
-            // InternalRoom.g:8802:1: ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) )
-            // InternalRoom.g:8803:1: ( rule__ProtocolClass__UserCode1Assignment_7_1 )
+            // InternalRoom.g:9001:1: ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) )
+            // InternalRoom.g:9002:1: ( rule__ProtocolClass__UserCode1Assignment_7_1 )
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode1Assignment_7_1()); 
-            // InternalRoom.g:8804:1: ( rule__ProtocolClass__UserCode1Assignment_7_1 )
-            // InternalRoom.g:8804:2: rule__ProtocolClass__UserCode1Assignment_7_1
+            // InternalRoom.g:9003:1: ( rule__ProtocolClass__UserCode1Assignment_7_1 )
+            // InternalRoom.g:9003:2: rule__ProtocolClass__UserCode1Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode1Assignment_7_1();
@@ -25674,14 +26242,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_8__0"
-    // InternalRoom.g:8818:1: rule__ProtocolClass__Group_8__0 : rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1 ;
+    // InternalRoom.g:9017:1: rule__ProtocolClass__Group_8__0 : rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1 ;
     public final void rule__ProtocolClass__Group_8__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8822:1: ( rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1 )
-            // InternalRoom.g:8823:2: rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1
+            // InternalRoom.g:9021:1: ( rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1 )
+            // InternalRoom.g:9022:2: rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_8__0__Impl();
@@ -25712,17 +26280,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_8__0__Impl"
-    // InternalRoom.g:8830:1: rule__ProtocolClass__Group_8__0__Impl : ( 'usercode2' ) ;
+    // InternalRoom.g:9029:1: rule__ProtocolClass__Group_8__0__Impl : ( 'usercode2' ) ;
     public final void rule__ProtocolClass__Group_8__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8834:1: ( ( 'usercode2' ) )
-            // InternalRoom.g:8835:1: ( 'usercode2' )
+            // InternalRoom.g:9033:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:9034:1: ( 'usercode2' )
             {
-            // InternalRoom.g:8835:1: ( 'usercode2' )
-            // InternalRoom.g:8836:1: 'usercode2'
+            // InternalRoom.g:9034:1: ( 'usercode2' )
+            // InternalRoom.g:9035:1: 'usercode2'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode2Keyword_8_0()); 
             match(input,59,FOLLOW_2); 
@@ -25749,14 +26317,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_8__1"
-    // InternalRoom.g:8849:1: rule__ProtocolClass__Group_8__1 : rule__ProtocolClass__Group_8__1__Impl ;
+    // InternalRoom.g:9048:1: rule__ProtocolClass__Group_8__1 : rule__ProtocolClass__Group_8__1__Impl ;
     public final void rule__ProtocolClass__Group_8__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8853:1: ( rule__ProtocolClass__Group_8__1__Impl )
-            // InternalRoom.g:8854:2: rule__ProtocolClass__Group_8__1__Impl
+            // InternalRoom.g:9052:1: ( rule__ProtocolClass__Group_8__1__Impl )
+            // InternalRoom.g:9053:2: rule__ProtocolClass__Group_8__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_8__1__Impl();
@@ -25782,21 +26350,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_8__1__Impl"
-    // InternalRoom.g:8860:1: rule__ProtocolClass__Group_8__1__Impl : ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) ) ;
+    // InternalRoom.g:9059:1: rule__ProtocolClass__Group_8__1__Impl : ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) ) ;
     public final void rule__ProtocolClass__Group_8__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8864:1: ( ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) ) )
-            // InternalRoom.g:8865:1: ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) )
+            // InternalRoom.g:9063:1: ( ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) ) )
+            // InternalRoom.g:9064:1: ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) )
             {
-            // InternalRoom.g:8865:1: ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) )
-            // InternalRoom.g:8866:1: ( rule__ProtocolClass__UserCode2Assignment_8_1 )
+            // InternalRoom.g:9064:1: ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) )
+            // InternalRoom.g:9065:1: ( rule__ProtocolClass__UserCode2Assignment_8_1 )
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode2Assignment_8_1()); 
-            // InternalRoom.g:8867:1: ( rule__ProtocolClass__UserCode2Assignment_8_1 )
-            // InternalRoom.g:8867:2: rule__ProtocolClass__UserCode2Assignment_8_1
+            // InternalRoom.g:9066:1: ( rule__ProtocolClass__UserCode2Assignment_8_1 )
+            // InternalRoom.g:9066:2: rule__ProtocolClass__UserCode2Assignment_8_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode2Assignment_8_1();
@@ -25829,14 +26397,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_9__0"
-    // InternalRoom.g:8881:1: rule__ProtocolClass__Group_9__0 : rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1 ;
+    // InternalRoom.g:9080:1: rule__ProtocolClass__Group_9__0 : rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1 ;
     public final void rule__ProtocolClass__Group_9__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8885:1: ( rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1 )
-            // InternalRoom.g:8886:2: rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1
+            // InternalRoom.g:9084:1: ( rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1 )
+            // InternalRoom.g:9085:2: rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_9__0__Impl();
@@ -25867,17 +26435,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_9__0__Impl"
-    // InternalRoom.g:8893:1: rule__ProtocolClass__Group_9__0__Impl : ( 'usercode3' ) ;
+    // InternalRoom.g:9092:1: rule__ProtocolClass__Group_9__0__Impl : ( 'usercode3' ) ;
     public final void rule__ProtocolClass__Group_9__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8897:1: ( ( 'usercode3' ) )
-            // InternalRoom.g:8898:1: ( 'usercode3' )
+            // InternalRoom.g:9096:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:9097:1: ( 'usercode3' )
             {
-            // InternalRoom.g:8898:1: ( 'usercode3' )
-            // InternalRoom.g:8899:1: 'usercode3'
+            // InternalRoom.g:9097:1: ( 'usercode3' )
+            // InternalRoom.g:9098:1: 'usercode3'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode3Keyword_9_0()); 
             match(input,60,FOLLOW_2); 
@@ -25904,14 +26472,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_9__1"
-    // InternalRoom.g:8912:1: rule__ProtocolClass__Group_9__1 : rule__ProtocolClass__Group_9__1__Impl ;
+    // InternalRoom.g:9111:1: rule__ProtocolClass__Group_9__1 : rule__ProtocolClass__Group_9__1__Impl ;
     public final void rule__ProtocolClass__Group_9__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8916:1: ( rule__ProtocolClass__Group_9__1__Impl )
-            // InternalRoom.g:8917:2: rule__ProtocolClass__Group_9__1__Impl
+            // InternalRoom.g:9115:1: ( rule__ProtocolClass__Group_9__1__Impl )
+            // InternalRoom.g:9116:2: rule__ProtocolClass__Group_9__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_9__1__Impl();
@@ -25937,21 +26505,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_9__1__Impl"
-    // InternalRoom.g:8923:1: rule__ProtocolClass__Group_9__1__Impl : ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) ) ;
+    // InternalRoom.g:9122:1: rule__ProtocolClass__Group_9__1__Impl : ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) ) ;
     public final void rule__ProtocolClass__Group_9__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8927:1: ( ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) ) )
-            // InternalRoom.g:8928:1: ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) )
+            // InternalRoom.g:9126:1: ( ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) ) )
+            // InternalRoom.g:9127:1: ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) )
             {
-            // InternalRoom.g:8928:1: ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) )
-            // InternalRoom.g:8929:1: ( rule__ProtocolClass__UserCode3Assignment_9_1 )
+            // InternalRoom.g:9127:1: ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) )
+            // InternalRoom.g:9128:1: ( rule__ProtocolClass__UserCode3Assignment_9_1 )
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode3Assignment_9_1()); 
-            // InternalRoom.g:8930:1: ( rule__ProtocolClass__UserCode3Assignment_9_1 )
-            // InternalRoom.g:8930:2: rule__ProtocolClass__UserCode3Assignment_9_1
+            // InternalRoom.g:9129:1: ( rule__ProtocolClass__UserCode3Assignment_9_1 )
+            // InternalRoom.g:9129:2: rule__ProtocolClass__UserCode3Assignment_9_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode3Assignment_9_1();
@@ -25984,14 +26552,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__0"
-    // InternalRoom.g:8944:1: rule__ProtocolClass__Group_10__0 : rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1 ;
+    // InternalRoom.g:9143:1: rule__ProtocolClass__Group_10__0 : rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1 ;
     public final void rule__ProtocolClass__Group_10__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8948:1: ( rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1 )
-            // InternalRoom.g:8949:2: rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1
+            // InternalRoom.g:9147:1: ( rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1 )
+            // InternalRoom.g:9148:2: rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_10__0__Impl();
@@ -26022,17 +26590,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__0__Impl"
-    // InternalRoom.g:8956:1: rule__ProtocolClass__Group_10__0__Impl : ( 'incoming' ) ;
+    // InternalRoom.g:9155:1: rule__ProtocolClass__Group_10__0__Impl : ( 'incoming' ) ;
     public final void rule__ProtocolClass__Group_10__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8960:1: ( ( 'incoming' ) )
-            // InternalRoom.g:8961:1: ( 'incoming' )
+            // InternalRoom.g:9159:1: ( ( 'incoming' ) )
+            // InternalRoom.g:9160:1: ( 'incoming' )
             {
-            // InternalRoom.g:8961:1: ( 'incoming' )
-            // InternalRoom.g:8962:1: 'incoming'
+            // InternalRoom.g:9160:1: ( 'incoming' )
+            // InternalRoom.g:9161:1: 'incoming'
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingKeyword_10_0()); 
             match(input,66,FOLLOW_2); 
@@ -26059,14 +26627,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__1"
-    // InternalRoom.g:8975:1: rule__ProtocolClass__Group_10__1 : rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2 ;
+    // InternalRoom.g:9174:1: rule__ProtocolClass__Group_10__1 : rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2 ;
     public final void rule__ProtocolClass__Group_10__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8979:1: ( rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2 )
-            // InternalRoom.g:8980:2: rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2
+            // InternalRoom.g:9178:1: ( rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2 )
+            // InternalRoom.g:9179:2: rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_10__1__Impl();
@@ -26097,17 +26665,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__1__Impl"
-    // InternalRoom.g:8987:1: rule__ProtocolClass__Group_10__1__Impl : ( '{' ) ;
+    // InternalRoom.g:9186:1: rule__ProtocolClass__Group_10__1__Impl : ( '{' ) ;
     public final void rule__ProtocolClass__Group_10__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:8991:1: ( ( '{' ) )
-            // InternalRoom.g:8992:1: ( '{' )
+            // InternalRoom.g:9190:1: ( ( '{' ) )
+            // InternalRoom.g:9191:1: ( '{' )
             {
-            // InternalRoom.g:8992:1: ( '{' )
-            // InternalRoom.g:8993:1: '{'
+            // InternalRoom.g:9191:1: ( '{' )
+            // InternalRoom.g:9192:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1()); 
             match(input,44,FOLLOW_2); 
@@ -26134,14 +26702,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__2"
-    // InternalRoom.g:9006:1: rule__ProtocolClass__Group_10__2 : rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3 ;
+    // InternalRoom.g:9205:1: rule__ProtocolClass__Group_10__2 : rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3 ;
     public final void rule__ProtocolClass__Group_10__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9010:1: ( rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3 )
-            // InternalRoom.g:9011:2: rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3
+            // InternalRoom.g:9209:1: ( rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3 )
+            // InternalRoom.g:9210:2: rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_10__2__Impl();
@@ -26172,33 +26740,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__2__Impl"
-    // InternalRoom.g:9018:1: rule__ProtocolClass__Group_10__2__Impl : ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* ) ;
+    // InternalRoom.g:9217:1: rule__ProtocolClass__Group_10__2__Impl : ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* ) ;
     public final void rule__ProtocolClass__Group_10__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9022:1: ( ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* ) )
-            // InternalRoom.g:9023:1: ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* )
+            // InternalRoom.g:9221:1: ( ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* ) )
+            // InternalRoom.g:9222:1: ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* )
             {
-            // InternalRoom.g:9023:1: ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* )
-            // InternalRoom.g:9024:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
+            // InternalRoom.g:9222:1: ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* )
+            // InternalRoom.g:9223:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingMessagesAssignment_10_2()); 
-            // InternalRoom.g:9025:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
-            loop100:
+            // InternalRoom.g:9224:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
+            loop102:
             do {
-                int alt100=2;
-                int LA100_0 = input.LA(1);
+                int alt102=2;
+                int LA102_0 = input.LA(1);
 
-                if ( (LA100_0==25||LA100_0==129) ) {
-                    alt100=1;
+                if ( (LA102_0==25||LA102_0==129) ) {
+                    alt102=1;
                 }
 
 
-                switch (alt100) {
+                switch (alt102) {
             	case 1 :
-            	    // InternalRoom.g:9025:2: rule__ProtocolClass__IncomingMessagesAssignment_10_2
+            	    // InternalRoom.g:9224:2: rule__ProtocolClass__IncomingMessagesAssignment_10_2
             	    {
             	    pushFollow(FOLLOW_42);
             	    rule__ProtocolClass__IncomingMessagesAssignment_10_2();
@@ -26210,7 +26778,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop100;
+            	    break loop102;
                 }
             } while (true);
 
@@ -26237,14 +26805,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__3"
-    // InternalRoom.g:9035:1: rule__ProtocolClass__Group_10__3 : rule__ProtocolClass__Group_10__3__Impl ;
+    // InternalRoom.g:9234:1: rule__ProtocolClass__Group_10__3 : rule__ProtocolClass__Group_10__3__Impl ;
     public final void rule__ProtocolClass__Group_10__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9039:1: ( rule__ProtocolClass__Group_10__3__Impl )
-            // InternalRoom.g:9040:2: rule__ProtocolClass__Group_10__3__Impl
+            // InternalRoom.g:9238:1: ( rule__ProtocolClass__Group_10__3__Impl )
+            // InternalRoom.g:9239:2: rule__ProtocolClass__Group_10__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_10__3__Impl();
@@ -26270,17 +26838,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_10__3__Impl"
-    // InternalRoom.g:9046:1: rule__ProtocolClass__Group_10__3__Impl : ( '}' ) ;
+    // InternalRoom.g:9245:1: rule__ProtocolClass__Group_10__3__Impl : ( '}' ) ;
     public final void rule__ProtocolClass__Group_10__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9050:1: ( ( '}' ) )
-            // InternalRoom.g:9051:1: ( '}' )
+            // InternalRoom.g:9249:1: ( ( '}' ) )
+            // InternalRoom.g:9250:1: ( '}' )
             {
-            // InternalRoom.g:9051:1: ( '}' )
-            // InternalRoom.g:9052:1: '}'
+            // InternalRoom.g:9250:1: ( '}' )
+            // InternalRoom.g:9251:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_10_3()); 
             match(input,45,FOLLOW_2); 
@@ -26307,14 +26875,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__0"
-    // InternalRoom.g:9073:1: rule__ProtocolClass__Group_11__0 : rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1 ;
+    // InternalRoom.g:9272:1: rule__ProtocolClass__Group_11__0 : rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1 ;
     public final void rule__ProtocolClass__Group_11__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9077:1: ( rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1 )
-            // InternalRoom.g:9078:2: rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1
+            // InternalRoom.g:9276:1: ( rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1 )
+            // InternalRoom.g:9277:2: rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_11__0__Impl();
@@ -26345,17 +26913,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__0__Impl"
-    // InternalRoom.g:9085:1: rule__ProtocolClass__Group_11__0__Impl : ( 'outgoing' ) ;
+    // InternalRoom.g:9284:1: rule__ProtocolClass__Group_11__0__Impl : ( 'outgoing' ) ;
     public final void rule__ProtocolClass__Group_11__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9089:1: ( ( 'outgoing' ) )
-            // InternalRoom.g:9090:1: ( 'outgoing' )
+            // InternalRoom.g:9288:1: ( ( 'outgoing' ) )
+            // InternalRoom.g:9289:1: ( 'outgoing' )
             {
-            // InternalRoom.g:9090:1: ( 'outgoing' )
-            // InternalRoom.g:9091:1: 'outgoing'
+            // InternalRoom.g:9289:1: ( 'outgoing' )
+            // InternalRoom.g:9290:1: 'outgoing'
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingKeyword_11_0()); 
             match(input,67,FOLLOW_2); 
@@ -26382,14 +26950,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__1"
-    // InternalRoom.g:9104:1: rule__ProtocolClass__Group_11__1 : rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2 ;
+    // InternalRoom.g:9303:1: rule__ProtocolClass__Group_11__1 : rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2 ;
     public final void rule__ProtocolClass__Group_11__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9108:1: ( rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2 )
-            // InternalRoom.g:9109:2: rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2
+            // InternalRoom.g:9307:1: ( rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2 )
+            // InternalRoom.g:9308:2: rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_11__1__Impl();
@@ -26420,17 +26988,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__1__Impl"
-    // InternalRoom.g:9116:1: rule__ProtocolClass__Group_11__1__Impl : ( '{' ) ;
+    // InternalRoom.g:9315:1: rule__ProtocolClass__Group_11__1__Impl : ( '{' ) ;
     public final void rule__ProtocolClass__Group_11__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9120:1: ( ( '{' ) )
-            // InternalRoom.g:9121:1: ( '{' )
+            // InternalRoom.g:9319:1: ( ( '{' ) )
+            // InternalRoom.g:9320:1: ( '{' )
             {
-            // InternalRoom.g:9121:1: ( '{' )
-            // InternalRoom.g:9122:1: '{'
+            // InternalRoom.g:9320:1: ( '{' )
+            // InternalRoom.g:9321:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1()); 
             match(input,44,FOLLOW_2); 
@@ -26457,14 +27025,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__2"
-    // InternalRoom.g:9135:1: rule__ProtocolClass__Group_11__2 : rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3 ;
+    // InternalRoom.g:9334:1: rule__ProtocolClass__Group_11__2 : rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3 ;
     public final void rule__ProtocolClass__Group_11__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9139:1: ( rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3 )
-            // InternalRoom.g:9140:2: rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3
+            // InternalRoom.g:9338:1: ( rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3 )
+            // InternalRoom.g:9339:2: rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_11__2__Impl();
@@ -26495,33 +27063,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__2__Impl"
-    // InternalRoom.g:9147:1: rule__ProtocolClass__Group_11__2__Impl : ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* ) ;
+    // InternalRoom.g:9346:1: rule__ProtocolClass__Group_11__2__Impl : ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* ) ;
     public final void rule__ProtocolClass__Group_11__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9151:1: ( ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* ) )
-            // InternalRoom.g:9152:1: ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* )
+            // InternalRoom.g:9350:1: ( ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* ) )
+            // InternalRoom.g:9351:1: ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* )
             {
-            // InternalRoom.g:9152:1: ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* )
-            // InternalRoom.g:9153:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
+            // InternalRoom.g:9351:1: ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* )
+            // InternalRoom.g:9352:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesAssignment_11_2()); 
-            // InternalRoom.g:9154:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
-            loop101:
+            // InternalRoom.g:9353:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
+            loop103:
             do {
-                int alt101=2;
-                int LA101_0 = input.LA(1);
+                int alt103=2;
+                int LA103_0 = input.LA(1);
 
-                if ( (LA101_0==25||LA101_0==129) ) {
-                    alt101=1;
+                if ( (LA103_0==25||LA103_0==129) ) {
+                    alt103=1;
                 }
 
 
-                switch (alt101) {
+                switch (alt103) {
             	case 1 :
-            	    // InternalRoom.g:9154:2: rule__ProtocolClass__OutgoingMessagesAssignment_11_2
+            	    // InternalRoom.g:9353:2: rule__ProtocolClass__OutgoingMessagesAssignment_11_2
             	    {
             	    pushFollow(FOLLOW_42);
             	    rule__ProtocolClass__OutgoingMessagesAssignment_11_2();
@@ -26533,7 +27101,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop101;
+            	    break loop103;
                 }
             } while (true);
 
@@ -26560,14 +27128,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__3"
-    // InternalRoom.g:9164:1: rule__ProtocolClass__Group_11__3 : rule__ProtocolClass__Group_11__3__Impl ;
+    // InternalRoom.g:9363:1: rule__ProtocolClass__Group_11__3 : rule__ProtocolClass__Group_11__3__Impl ;
     public final void rule__ProtocolClass__Group_11__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9168:1: ( rule__ProtocolClass__Group_11__3__Impl )
-            // InternalRoom.g:9169:2: rule__ProtocolClass__Group_11__3__Impl
+            // InternalRoom.g:9367:1: ( rule__ProtocolClass__Group_11__3__Impl )
+            // InternalRoom.g:9368:2: rule__ProtocolClass__Group_11__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_11__3__Impl();
@@ -26593,17 +27161,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_11__3__Impl"
-    // InternalRoom.g:9175:1: rule__ProtocolClass__Group_11__3__Impl : ( '}' ) ;
+    // InternalRoom.g:9374:1: rule__ProtocolClass__Group_11__3__Impl : ( '}' ) ;
     public final void rule__ProtocolClass__Group_11__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9179:1: ( ( '}' ) )
-            // InternalRoom.g:9180:1: ( '}' )
+            // InternalRoom.g:9378:1: ( ( '}' ) )
+            // InternalRoom.g:9379:1: ( '}' )
             {
-            // InternalRoom.g:9180:1: ( '}' )
-            // InternalRoom.g:9181:1: '}'
+            // InternalRoom.g:9379:1: ( '}' )
+            // InternalRoom.g:9380:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_11_3()); 
             match(input,45,FOLLOW_2); 
@@ -26630,14 +27198,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__0"
-    // InternalRoom.g:9202:1: rule__ProtocolClass__Group_12__0 : rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1 ;
+    // InternalRoom.g:9401:1: rule__ProtocolClass__Group_12__0 : rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1 ;
     public final void rule__ProtocolClass__Group_12__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9206:1: ( rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1 )
-            // InternalRoom.g:9207:2: rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1
+            // InternalRoom.g:9405:1: ( rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1 )
+            // InternalRoom.g:9406:2: rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1
             {
             pushFollow(FOLLOW_43);
             rule__ProtocolClass__Group_12__0__Impl();
@@ -26668,17 +27236,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__0__Impl"
-    // InternalRoom.g:9214:1: rule__ProtocolClass__Group_12__0__Impl : ( 'regular' ) ;
+    // InternalRoom.g:9413:1: rule__ProtocolClass__Group_12__0__Impl : ( 'regular' ) ;
     public final void rule__ProtocolClass__Group_12__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9218:1: ( ( 'regular' ) )
-            // InternalRoom.g:9219:1: ( 'regular' )
+            // InternalRoom.g:9417:1: ( ( 'regular' ) )
+            // InternalRoom.g:9418:1: ( 'regular' )
             {
-            // InternalRoom.g:9219:1: ( 'regular' )
-            // InternalRoom.g:9220:1: 'regular'
+            // InternalRoom.g:9418:1: ( 'regular' )
+            // InternalRoom.g:9419:1: 'regular'
             {
              before(grammarAccess.getProtocolClassAccess().getRegularKeyword_12_0()); 
             match(input,68,FOLLOW_2); 
@@ -26705,14 +27273,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__1"
-    // InternalRoom.g:9233:1: rule__ProtocolClass__Group_12__1 : rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2 ;
+    // InternalRoom.g:9432:1: rule__ProtocolClass__Group_12__1 : rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2 ;
     public final void rule__ProtocolClass__Group_12__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9237:1: ( rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2 )
-            // InternalRoom.g:9238:2: rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2
+            // InternalRoom.g:9436:1: ( rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2 )
+            // InternalRoom.g:9437:2: rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_12__1__Impl();
@@ -26743,17 +27311,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__1__Impl"
-    // InternalRoom.g:9245:1: rule__ProtocolClass__Group_12__1__Impl : ( 'PortClass' ) ;
+    // InternalRoom.g:9444:1: rule__ProtocolClass__Group_12__1__Impl : ( 'PortClass' ) ;
     public final void rule__ProtocolClass__Group_12__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9249:1: ( ( 'PortClass' ) )
-            // InternalRoom.g:9250:1: ( 'PortClass' )
+            // InternalRoom.g:9448:1: ( ( 'PortClass' ) )
+            // InternalRoom.g:9449:1: ( 'PortClass' )
             {
-            // InternalRoom.g:9250:1: ( 'PortClass' )
-            // InternalRoom.g:9251:1: 'PortClass'
+            // InternalRoom.g:9449:1: ( 'PortClass' )
+            // InternalRoom.g:9450:1: 'PortClass'
             {
              before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_12_1()); 
             match(input,69,FOLLOW_2); 
@@ -26780,14 +27348,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__2"
-    // InternalRoom.g:9264:1: rule__ProtocolClass__Group_12__2 : rule__ProtocolClass__Group_12__2__Impl ;
+    // InternalRoom.g:9463:1: rule__ProtocolClass__Group_12__2 : rule__ProtocolClass__Group_12__2__Impl ;
     public final void rule__ProtocolClass__Group_12__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9268:1: ( rule__ProtocolClass__Group_12__2__Impl )
-            // InternalRoom.g:9269:2: rule__ProtocolClass__Group_12__2__Impl
+            // InternalRoom.g:9467:1: ( rule__ProtocolClass__Group_12__2__Impl )
+            // InternalRoom.g:9468:2: rule__ProtocolClass__Group_12__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_12__2__Impl();
@@ -26813,21 +27381,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_12__2__Impl"
-    // InternalRoom.g:9275:1: rule__ProtocolClass__Group_12__2__Impl : ( ( rule__ProtocolClass__RegularAssignment_12_2 ) ) ;
+    // InternalRoom.g:9474:1: rule__ProtocolClass__Group_12__2__Impl : ( ( rule__ProtocolClass__RegularAssignment_12_2 ) ) ;
     public final void rule__ProtocolClass__Group_12__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9279:1: ( ( ( rule__ProtocolClass__RegularAssignment_12_2 ) ) )
-            // InternalRoom.g:9280:1: ( ( rule__ProtocolClass__RegularAssignment_12_2 ) )
+            // InternalRoom.g:9478:1: ( ( ( rule__ProtocolClass__RegularAssignment_12_2 ) ) )
+            // InternalRoom.g:9479:1: ( ( rule__ProtocolClass__RegularAssignment_12_2 ) )
             {
-            // InternalRoom.g:9280:1: ( ( rule__ProtocolClass__RegularAssignment_12_2 ) )
-            // InternalRoom.g:9281:1: ( rule__ProtocolClass__RegularAssignment_12_2 )
+            // InternalRoom.g:9479:1: ( ( rule__ProtocolClass__RegularAssignment_12_2 ) )
+            // InternalRoom.g:9480:1: ( rule__ProtocolClass__RegularAssignment_12_2 )
             {
              before(grammarAccess.getProtocolClassAccess().getRegularAssignment_12_2()); 
-            // InternalRoom.g:9282:1: ( rule__ProtocolClass__RegularAssignment_12_2 )
-            // InternalRoom.g:9282:2: rule__ProtocolClass__RegularAssignment_12_2
+            // InternalRoom.g:9481:1: ( rule__ProtocolClass__RegularAssignment_12_2 )
+            // InternalRoom.g:9481:2: rule__ProtocolClass__RegularAssignment_12_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__RegularAssignment_12_2();
@@ -26860,14 +27428,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__0"
-    // InternalRoom.g:9298:1: rule__ProtocolClass__Group_13__0 : rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1 ;
+    // InternalRoom.g:9497:1: rule__ProtocolClass__Group_13__0 : rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1 ;
     public final void rule__ProtocolClass__Group_13__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9302:1: ( rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1 )
-            // InternalRoom.g:9303:2: rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1
+            // InternalRoom.g:9501:1: ( rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1 )
+            // InternalRoom.g:9502:2: rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1
             {
             pushFollow(FOLLOW_43);
             rule__ProtocolClass__Group_13__0__Impl();
@@ -26898,17 +27466,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__0__Impl"
-    // InternalRoom.g:9310:1: rule__ProtocolClass__Group_13__0__Impl : ( 'conjugated' ) ;
+    // InternalRoom.g:9509:1: rule__ProtocolClass__Group_13__0__Impl : ( 'conjugated' ) ;
     public final void rule__ProtocolClass__Group_13__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9314:1: ( ( 'conjugated' ) )
-            // InternalRoom.g:9315:1: ( 'conjugated' )
+            // InternalRoom.g:9513:1: ( ( 'conjugated' ) )
+            // InternalRoom.g:9514:1: ( 'conjugated' )
             {
-            // InternalRoom.g:9315:1: ( 'conjugated' )
-            // InternalRoom.g:9316:1: 'conjugated'
+            // InternalRoom.g:9514:1: ( 'conjugated' )
+            // InternalRoom.g:9515:1: 'conjugated'
             {
              before(grammarAccess.getProtocolClassAccess().getConjugatedKeyword_13_0()); 
             match(input,70,FOLLOW_2); 
@@ -26935,14 +27503,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__1"
-    // InternalRoom.g:9329:1: rule__ProtocolClass__Group_13__1 : rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2 ;
+    // InternalRoom.g:9528:1: rule__ProtocolClass__Group_13__1 : rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2 ;
     public final void rule__ProtocolClass__Group_13__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9333:1: ( rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2 )
-            // InternalRoom.g:9334:2: rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2
+            // InternalRoom.g:9532:1: ( rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2 )
+            // InternalRoom.g:9533:2: rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_13__1__Impl();
@@ -26973,17 +27541,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__1__Impl"
-    // InternalRoom.g:9341:1: rule__ProtocolClass__Group_13__1__Impl : ( 'PortClass' ) ;
+    // InternalRoom.g:9540:1: rule__ProtocolClass__Group_13__1__Impl : ( 'PortClass' ) ;
     public final void rule__ProtocolClass__Group_13__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9345:1: ( ( 'PortClass' ) )
-            // InternalRoom.g:9346:1: ( 'PortClass' )
+            // InternalRoom.g:9544:1: ( ( 'PortClass' ) )
+            // InternalRoom.g:9545:1: ( 'PortClass' )
             {
-            // InternalRoom.g:9346:1: ( 'PortClass' )
-            // InternalRoom.g:9347:1: 'PortClass'
+            // InternalRoom.g:9545:1: ( 'PortClass' )
+            // InternalRoom.g:9546:1: 'PortClass'
             {
              before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_13_1()); 
             match(input,69,FOLLOW_2); 
@@ -27010,14 +27578,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__2"
-    // InternalRoom.g:9360:1: rule__ProtocolClass__Group_13__2 : rule__ProtocolClass__Group_13__2__Impl ;
+    // InternalRoom.g:9559:1: rule__ProtocolClass__Group_13__2 : rule__ProtocolClass__Group_13__2__Impl ;
     public final void rule__ProtocolClass__Group_13__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9364:1: ( rule__ProtocolClass__Group_13__2__Impl )
-            // InternalRoom.g:9365:2: rule__ProtocolClass__Group_13__2__Impl
+            // InternalRoom.g:9563:1: ( rule__ProtocolClass__Group_13__2__Impl )
+            // InternalRoom.g:9564:2: rule__ProtocolClass__Group_13__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_13__2__Impl();
@@ -27043,21 +27611,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group_13__2__Impl"
-    // InternalRoom.g:9371:1: rule__ProtocolClass__Group_13__2__Impl : ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) ) ;
+    // InternalRoom.g:9570:1: rule__ProtocolClass__Group_13__2__Impl : ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) ) ;
     public final void rule__ProtocolClass__Group_13__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9375:1: ( ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) ) )
-            // InternalRoom.g:9376:1: ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) )
+            // InternalRoom.g:9574:1: ( ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) ) )
+            // InternalRoom.g:9575:1: ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) )
             {
-            // InternalRoom.g:9376:1: ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) )
-            // InternalRoom.g:9377:1: ( rule__ProtocolClass__ConjugatedAssignment_13_2 )
+            // InternalRoom.g:9575:1: ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) )
+            // InternalRoom.g:9576:1: ( rule__ProtocolClass__ConjugatedAssignment_13_2 )
             {
              before(grammarAccess.getProtocolClassAccess().getConjugatedAssignment_13_2()); 
-            // InternalRoom.g:9378:1: ( rule__ProtocolClass__ConjugatedAssignment_13_2 )
-            // InternalRoom.g:9378:2: rule__ProtocolClass__ConjugatedAssignment_13_2
+            // InternalRoom.g:9577:1: ( rule__ProtocolClass__ConjugatedAssignment_13_2 )
+            // InternalRoom.g:9577:2: rule__ProtocolClass__ConjugatedAssignment_13_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__ConjugatedAssignment_13_2();
@@ -27090,14 +27658,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__0"
-    // InternalRoom.g:9394:1: rule__CompoundProtocolClass__Group__0 : rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1 ;
+    // InternalRoom.g:9593:1: rule__CompoundProtocolClass__Group__0 : rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1 ;
     public final void rule__CompoundProtocolClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9398:1: ( rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1 )
-            // InternalRoom.g:9399:2: rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1
+            // InternalRoom.g:9597:1: ( rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1 )
+            // InternalRoom.g:9598:2: rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__CompoundProtocolClass__Group__0__Impl();
@@ -27128,17 +27696,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__0__Impl"
-    // InternalRoom.g:9406:1: rule__CompoundProtocolClass__Group__0__Impl : ( 'CompoundProtocolClass' ) ;
+    // InternalRoom.g:9605:1: rule__CompoundProtocolClass__Group__0__Impl : ( 'CompoundProtocolClass' ) ;
     public final void rule__CompoundProtocolClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9410:1: ( ( 'CompoundProtocolClass' ) )
-            // InternalRoom.g:9411:1: ( 'CompoundProtocolClass' )
+            // InternalRoom.g:9609:1: ( ( 'CompoundProtocolClass' ) )
+            // InternalRoom.g:9610:1: ( 'CompoundProtocolClass' )
             {
-            // InternalRoom.g:9411:1: ( 'CompoundProtocolClass' )
-            // InternalRoom.g:9412:1: 'CompoundProtocolClass'
+            // InternalRoom.g:9610:1: ( 'CompoundProtocolClass' )
+            // InternalRoom.g:9611:1: 'CompoundProtocolClass'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getCompoundProtocolClassKeyword_0()); 
             match(input,21,FOLLOW_2); 
@@ -27165,14 +27733,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__1"
-    // InternalRoom.g:9425:1: rule__CompoundProtocolClass__Group__1 : rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2 ;
+    // InternalRoom.g:9624:1: rule__CompoundProtocolClass__Group__1 : rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2 ;
     public final void rule__CompoundProtocolClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9429:1: ( rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2 )
-            // InternalRoom.g:9430:2: rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2
+            // InternalRoom.g:9628:1: ( rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2 )
+            // InternalRoom.g:9629:2: rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__CompoundProtocolClass__Group__1__Impl();
@@ -27203,21 +27771,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__1__Impl"
-    // InternalRoom.g:9437:1: rule__CompoundProtocolClass__Group__1__Impl : ( ( rule__CompoundProtocolClass__NameAssignment_1 ) ) ;
+    // InternalRoom.g:9636:1: rule__CompoundProtocolClass__Group__1__Impl : ( ( rule__CompoundProtocolClass__NameAssignment_1 ) ) ;
     public final void rule__CompoundProtocolClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9441:1: ( ( ( rule__CompoundProtocolClass__NameAssignment_1 ) ) )
-            // InternalRoom.g:9442:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
+            // InternalRoom.g:9640:1: ( ( ( rule__CompoundProtocolClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:9641:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:9442:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
-            // InternalRoom.g:9443:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
+            // InternalRoom.g:9641:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
+            // InternalRoom.g:9642:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getNameAssignment_1()); 
-            // InternalRoom.g:9444:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
-            // InternalRoom.g:9444:2: rule__CompoundProtocolClass__NameAssignment_1
+            // InternalRoom.g:9643:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
+            // InternalRoom.g:9643:2: rule__CompoundProtocolClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__CompoundProtocolClass__NameAssignment_1();
@@ -27250,14 +27818,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__2"
-    // InternalRoom.g:9454:1: rule__CompoundProtocolClass__Group__2 : rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3 ;
+    // InternalRoom.g:9653:1: rule__CompoundProtocolClass__Group__2 : rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3 ;
     public final void rule__CompoundProtocolClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9458:1: ( rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3 )
-            // InternalRoom.g:9459:2: rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3
+            // InternalRoom.g:9657:1: ( rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3 )
+            // InternalRoom.g:9658:2: rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__CompoundProtocolClass__Group__2__Impl();
@@ -27288,29 +27856,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__2__Impl"
-    // InternalRoom.g:9466:1: rule__CompoundProtocolClass__Group__2__Impl : ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:9665:1: rule__CompoundProtocolClass__Group__2__Impl : ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? ) ;
     public final void rule__CompoundProtocolClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9470:1: ( ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? ) )
-            // InternalRoom.g:9471:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
+            // InternalRoom.g:9669:1: ( ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:9670:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:9471:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
-            // InternalRoom.g:9472:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
+            // InternalRoom.g:9670:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
+            // InternalRoom.g:9671:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:9473:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
-            int alt102=2;
-            int LA102_0 = input.LA(1);
+            // InternalRoom.g:9672:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
+            int alt104=2;
+            int LA104_0 = input.LA(1);
 
-            if ( (LA102_0==62) ) {
-                alt102=1;
+            if ( (LA104_0==62) ) {
+                alt104=1;
             }
-            switch (alt102) {
+            switch (alt104) {
                 case 1 :
-                    // InternalRoom.g:9473:2: rule__CompoundProtocolClass__DocuAssignment_2
+                    // InternalRoom.g:9672:2: rule__CompoundProtocolClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__CompoundProtocolClass__DocuAssignment_2();
@@ -27346,14 +27914,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__3"
-    // InternalRoom.g:9483:1: rule__CompoundProtocolClass__Group__3 : rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4 ;
+    // InternalRoom.g:9682:1: rule__CompoundProtocolClass__Group__3 : rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4 ;
     public final void rule__CompoundProtocolClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9487:1: ( rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4 )
-            // InternalRoom.g:9488:2: rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4
+            // InternalRoom.g:9686:1: ( rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4 )
+            // InternalRoom.g:9687:2: rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__3__Impl();
@@ -27384,17 +27952,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__3__Impl"
-    // InternalRoom.g:9495:1: rule__CompoundProtocolClass__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:9694:1: rule__CompoundProtocolClass__Group__3__Impl : ( '{' ) ;
     public final void rule__CompoundProtocolClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9499:1: ( ( '{' ) )
-            // InternalRoom.g:9500:1: ( '{' )
+            // InternalRoom.g:9698:1: ( ( '{' ) )
+            // InternalRoom.g:9699:1: ( '{' )
             {
-            // InternalRoom.g:9500:1: ( '{' )
-            // InternalRoom.g:9501:1: '{'
+            // InternalRoom.g:9699:1: ( '{' )
+            // InternalRoom.g:9700:1: '{'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -27421,14 +27989,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__4"
-    // InternalRoom.g:9514:1: rule__CompoundProtocolClass__Group__4 : rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5 ;
+    // InternalRoom.g:9713:1: rule__CompoundProtocolClass__Group__4 : rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5 ;
     public final void rule__CompoundProtocolClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9518:1: ( rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5 )
-            // InternalRoom.g:9519:2: rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5
+            // InternalRoom.g:9717:1: ( rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5 )
+            // InternalRoom.g:9718:2: rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__4__Impl();
@@ -27459,33 +28027,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__4__Impl"
-    // InternalRoom.g:9526:1: rule__CompoundProtocolClass__Group__4__Impl : ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* ) ;
+    // InternalRoom.g:9725:1: rule__CompoundProtocolClass__Group__4__Impl : ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* ) ;
     public final void rule__CompoundProtocolClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9530:1: ( ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* ) )
-            // InternalRoom.g:9531:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:9729:1: ( ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:9730:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:9531:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:9532:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
+            // InternalRoom.g:9730:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:9731:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:9533:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
-            loop103:
+            // InternalRoom.g:9732:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
+            loop105:
             do {
-                int alt103=2;
-                int LA103_0 = input.LA(1);
+                int alt105=2;
+                int LA105_0 = input.LA(1);
 
-                if ( (LA103_0==121) ) {
-                    alt103=1;
+                if ( (LA105_0==121) ) {
+                    alt105=1;
                 }
 
 
-                switch (alt103) {
+                switch (alt105) {
             	case 1 :
-            	    // InternalRoom.g:9533:2: rule__CompoundProtocolClass__AnnotationsAssignment_4
+            	    // InternalRoom.g:9732:2: rule__CompoundProtocolClass__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__CompoundProtocolClass__AnnotationsAssignment_4();
@@ -27497,7 +28065,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop103;
+            	    break loop105;
                 }
             } while (true);
 
@@ -27524,14 +28092,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__5"
-    // InternalRoom.g:9543:1: rule__CompoundProtocolClass__Group__5 : rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6 ;
+    // InternalRoom.g:9742:1: rule__CompoundProtocolClass__Group__5 : rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6 ;
     public final void rule__CompoundProtocolClass__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9547:1: ( rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6 )
-            // InternalRoom.g:9548:2: rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6
+            // InternalRoom.g:9746:1: ( rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6 )
+            // InternalRoom.g:9747:2: rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__5__Impl();
@@ -27562,33 +28130,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__5__Impl"
-    // InternalRoom.g:9555:1: rule__CompoundProtocolClass__Group__5__Impl : ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* ) ;
+    // InternalRoom.g:9754:1: rule__CompoundProtocolClass__Group__5__Impl : ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* ) ;
     public final void rule__CompoundProtocolClass__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9559:1: ( ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* ) )
-            // InternalRoom.g:9560:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
+            // InternalRoom.g:9758:1: ( ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* ) )
+            // InternalRoom.g:9759:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
             {
-            // InternalRoom.g:9560:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
-            // InternalRoom.g:9561:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
+            // InternalRoom.g:9759:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
+            // InternalRoom.g:9760:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsAssignment_5()); 
-            // InternalRoom.g:9562:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
-            loop104:
+            // InternalRoom.g:9761:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
+            loop106:
             do {
-                int alt104=2;
-                int LA104_0 = input.LA(1);
+                int alt106=2;
+                int LA106_0 = input.LA(1);
 
-                if ( (LA104_0==71) ) {
-                    alt104=1;
+                if ( (LA106_0==71) ) {
+                    alt106=1;
                 }
 
 
-                switch (alt104) {
+                switch (alt106) {
             	case 1 :
-            	    // InternalRoom.g:9562:2: rule__CompoundProtocolClass__SubProtocolsAssignment_5
+            	    // InternalRoom.g:9761:2: rule__CompoundProtocolClass__SubProtocolsAssignment_5
             	    {
             	    pushFollow(FOLLOW_45);
             	    rule__CompoundProtocolClass__SubProtocolsAssignment_5();
@@ -27600,7 +28168,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop104;
+            	    break loop106;
                 }
             } while (true);
 
@@ -27627,14 +28195,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__6"
-    // InternalRoom.g:9572:1: rule__CompoundProtocolClass__Group__6 : rule__CompoundProtocolClass__Group__6__Impl ;
+    // InternalRoom.g:9771:1: rule__CompoundProtocolClass__Group__6 : rule__CompoundProtocolClass__Group__6__Impl ;
     public final void rule__CompoundProtocolClass__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9576:1: ( rule__CompoundProtocolClass__Group__6__Impl )
-            // InternalRoom.g:9577:2: rule__CompoundProtocolClass__Group__6__Impl
+            // InternalRoom.g:9775:1: ( rule__CompoundProtocolClass__Group__6__Impl )
+            // InternalRoom.g:9776:2: rule__CompoundProtocolClass__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CompoundProtocolClass__Group__6__Impl();
@@ -27660,17 +28228,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__6__Impl"
-    // InternalRoom.g:9583:1: rule__CompoundProtocolClass__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:9782:1: rule__CompoundProtocolClass__Group__6__Impl : ( '}' ) ;
     public final void rule__CompoundProtocolClass__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9587:1: ( ( '}' ) )
-            // InternalRoom.g:9588:1: ( '}' )
+            // InternalRoom.g:9786:1: ( ( '}' ) )
+            // InternalRoom.g:9787:1: ( '}' )
             {
-            // InternalRoom.g:9588:1: ( '}' )
-            // InternalRoom.g:9589:1: '}'
+            // InternalRoom.g:9787:1: ( '}' )
+            // InternalRoom.g:9788:1: '}'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -27697,14 +28265,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__0"
-    // InternalRoom.g:9616:1: rule__SubProtocol__Group__0 : rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1 ;
+    // InternalRoom.g:9815:1: rule__SubProtocol__Group__0 : rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1 ;
     public final void rule__SubProtocol__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9620:1: ( rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1 )
-            // InternalRoom.g:9621:2: rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1
+            // InternalRoom.g:9819:1: ( rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1 )
+            // InternalRoom.g:9820:2: rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubProtocol__Group__0__Impl();
@@ -27735,17 +28303,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__0__Impl"
-    // InternalRoom.g:9628:1: rule__SubProtocol__Group__0__Impl : ( 'SubProtocol' ) ;
+    // InternalRoom.g:9827:1: rule__SubProtocol__Group__0__Impl : ( 'SubProtocol' ) ;
     public final void rule__SubProtocol__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9632:1: ( ( 'SubProtocol' ) )
-            // InternalRoom.g:9633:1: ( 'SubProtocol' )
+            // InternalRoom.g:9831:1: ( ( 'SubProtocol' ) )
+            // InternalRoom.g:9832:1: ( 'SubProtocol' )
             {
-            // InternalRoom.g:9633:1: ( 'SubProtocol' )
-            // InternalRoom.g:9634:1: 'SubProtocol'
+            // InternalRoom.g:9832:1: ( 'SubProtocol' )
+            // InternalRoom.g:9833:1: 'SubProtocol'
             {
              before(grammarAccess.getSubProtocolAccess().getSubProtocolKeyword_0()); 
             match(input,71,FOLLOW_2); 
@@ -27772,14 +28340,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__1"
-    // InternalRoom.g:9647:1: rule__SubProtocol__Group__1 : rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2 ;
+    // InternalRoom.g:9846:1: rule__SubProtocol__Group__1 : rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2 ;
     public final void rule__SubProtocol__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9651:1: ( rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2 )
-            // InternalRoom.g:9652:2: rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2
+            // InternalRoom.g:9850:1: ( rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2 )
+            // InternalRoom.g:9851:2: rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SubProtocol__Group__1__Impl();
@@ -27810,21 +28378,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__1__Impl"
-    // InternalRoom.g:9659:1: rule__SubProtocol__Group__1__Impl : ( ( rule__SubProtocol__NameAssignment_1 ) ) ;
+    // InternalRoom.g:9858:1: rule__SubProtocol__Group__1__Impl : ( ( rule__SubProtocol__NameAssignment_1 ) ) ;
     public final void rule__SubProtocol__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9663:1: ( ( ( rule__SubProtocol__NameAssignment_1 ) ) )
-            // InternalRoom.g:9664:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
+            // InternalRoom.g:9862:1: ( ( ( rule__SubProtocol__NameAssignment_1 ) ) )
+            // InternalRoom.g:9863:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
             {
-            // InternalRoom.g:9664:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
-            // InternalRoom.g:9665:1: ( rule__SubProtocol__NameAssignment_1 )
+            // InternalRoom.g:9863:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
+            // InternalRoom.g:9864:1: ( rule__SubProtocol__NameAssignment_1 )
             {
              before(grammarAccess.getSubProtocolAccess().getNameAssignment_1()); 
-            // InternalRoom.g:9666:1: ( rule__SubProtocol__NameAssignment_1 )
-            // InternalRoom.g:9666:2: rule__SubProtocol__NameAssignment_1
+            // InternalRoom.g:9865:1: ( rule__SubProtocol__NameAssignment_1 )
+            // InternalRoom.g:9865:2: rule__SubProtocol__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__NameAssignment_1();
@@ -27857,14 +28425,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__2"
-    // InternalRoom.g:9676:1: rule__SubProtocol__Group__2 : rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3 ;
+    // InternalRoom.g:9875:1: rule__SubProtocol__Group__2 : rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3 ;
     public final void rule__SubProtocol__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9680:1: ( rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3 )
-            // InternalRoom.g:9681:2: rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3
+            // InternalRoom.g:9879:1: ( rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3 )
+            // InternalRoom.g:9880:2: rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SubProtocol__Group__2__Impl();
@@ -27895,17 +28463,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__2__Impl"
-    // InternalRoom.g:9688:1: rule__SubProtocol__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:9887:1: rule__SubProtocol__Group__2__Impl : ( ':' ) ;
     public final void rule__SubProtocol__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9692:1: ( ( ':' ) )
-            // InternalRoom.g:9693:1: ( ':' )
+            // InternalRoom.g:9891:1: ( ( ':' ) )
+            // InternalRoom.g:9892:1: ( ':' )
             {
-            // InternalRoom.g:9693:1: ( ':' )
-            // InternalRoom.g:9694:1: ':'
+            // InternalRoom.g:9892:1: ( ':' )
+            // InternalRoom.g:9893:1: ':'
             {
              before(grammarAccess.getSubProtocolAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -27932,14 +28500,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__3"
-    // InternalRoom.g:9707:1: rule__SubProtocol__Group__3 : rule__SubProtocol__Group__3__Impl ;
+    // InternalRoom.g:9906:1: rule__SubProtocol__Group__3 : rule__SubProtocol__Group__3__Impl ;
     public final void rule__SubProtocol__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9711:1: ( rule__SubProtocol__Group__3__Impl )
-            // InternalRoom.g:9712:2: rule__SubProtocol__Group__3__Impl
+            // InternalRoom.g:9910:1: ( rule__SubProtocol__Group__3__Impl )
+            // InternalRoom.g:9911:2: rule__SubProtocol__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__Group__3__Impl();
@@ -27965,21 +28533,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__3__Impl"
-    // InternalRoom.g:9718:1: rule__SubProtocol__Group__3__Impl : ( ( rule__SubProtocol__ProtocolAssignment_3 ) ) ;
+    // InternalRoom.g:9917:1: rule__SubProtocol__Group__3__Impl : ( ( rule__SubProtocol__ProtocolAssignment_3 ) ) ;
     public final void rule__SubProtocol__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9722:1: ( ( ( rule__SubProtocol__ProtocolAssignment_3 ) ) )
-            // InternalRoom.g:9723:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
+            // InternalRoom.g:9921:1: ( ( ( rule__SubProtocol__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:9922:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:9723:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
-            // InternalRoom.g:9724:1: ( rule__SubProtocol__ProtocolAssignment_3 )
+            // InternalRoom.g:9922:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
+            // InternalRoom.g:9923:1: ( rule__SubProtocol__ProtocolAssignment_3 )
             {
              before(grammarAccess.getSubProtocolAccess().getProtocolAssignment_3()); 
-            // InternalRoom.g:9725:1: ( rule__SubProtocol__ProtocolAssignment_3 )
-            // InternalRoom.g:9725:2: rule__SubProtocol__ProtocolAssignment_3
+            // InternalRoom.g:9924:1: ( rule__SubProtocol__ProtocolAssignment_3 )
+            // InternalRoom.g:9924:2: rule__SubProtocol__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__ProtocolAssignment_3();
@@ -28012,14 +28580,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__0"
-    // InternalRoom.g:9743:1: rule__Message__Group__0 : rule__Message__Group__0__Impl rule__Message__Group__1 ;
+    // InternalRoom.g:9942:1: rule__Message__Group__0 : rule__Message__Group__0__Impl rule__Message__Group__1 ;
     public final void rule__Message__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9747:1: ( rule__Message__Group__0__Impl rule__Message__Group__1 )
-            // InternalRoom.g:9748:2: rule__Message__Group__0__Impl rule__Message__Group__1
+            // InternalRoom.g:9946:1: ( rule__Message__Group__0__Impl rule__Message__Group__1 )
+            // InternalRoom.g:9947:2: rule__Message__Group__0__Impl rule__Message__Group__1
             {
             pushFollow(FOLLOW_46);
             rule__Message__Group__0__Impl();
@@ -28050,29 +28618,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__0__Impl"
-    // InternalRoom.g:9755:1: rule__Message__Group__0__Impl : ( ( rule__Message__PrivAssignment_0 )? ) ;
+    // InternalRoom.g:9954:1: rule__Message__Group__0__Impl : ( ( rule__Message__PrivAssignment_0 )? ) ;
     public final void rule__Message__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9759:1: ( ( ( rule__Message__PrivAssignment_0 )? ) )
-            // InternalRoom.g:9760:1: ( ( rule__Message__PrivAssignment_0 )? )
+            // InternalRoom.g:9958:1: ( ( ( rule__Message__PrivAssignment_0 )? ) )
+            // InternalRoom.g:9959:1: ( ( rule__Message__PrivAssignment_0 )? )
             {
-            // InternalRoom.g:9760:1: ( ( rule__Message__PrivAssignment_0 )? )
-            // InternalRoom.g:9761:1: ( rule__Message__PrivAssignment_0 )?
+            // InternalRoom.g:9959:1: ( ( rule__Message__PrivAssignment_0 )? )
+            // InternalRoom.g:9960:1: ( rule__Message__PrivAssignment_0 )?
             {
              before(grammarAccess.getMessageAccess().getPrivAssignment_0()); 
-            // InternalRoom.g:9762:1: ( rule__Message__PrivAssignment_0 )?
-            int alt105=2;
-            int LA105_0 = input.LA(1);
+            // InternalRoom.g:9961:1: ( rule__Message__PrivAssignment_0 )?
+            int alt107=2;
+            int LA107_0 = input.LA(1);
 
-            if ( (LA105_0==129) ) {
-                alt105=1;
+            if ( (LA107_0==129) ) {
+                alt107=1;
             }
-            switch (alt105) {
+            switch (alt107) {
                 case 1 :
-                    // InternalRoom.g:9762:2: rule__Message__PrivAssignment_0
+                    // InternalRoom.g:9961:2: rule__Message__PrivAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Message__PrivAssignment_0();
@@ -28108,14 +28676,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__1"
-    // InternalRoom.g:9772:1: rule__Message__Group__1 : rule__Message__Group__1__Impl rule__Message__Group__2 ;
+    // InternalRoom.g:9971:1: rule__Message__Group__1 : rule__Message__Group__1__Impl rule__Message__Group__2 ;
     public final void rule__Message__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9776:1: ( rule__Message__Group__1__Impl rule__Message__Group__2 )
-            // InternalRoom.g:9777:2: rule__Message__Group__1__Impl rule__Message__Group__2
+            // InternalRoom.g:9975:1: ( rule__Message__Group__1__Impl rule__Message__Group__2 )
+            // InternalRoom.g:9976:2: rule__Message__Group__1__Impl rule__Message__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__Message__Group__1__Impl();
@@ -28146,17 +28714,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__1__Impl"
-    // InternalRoom.g:9784:1: rule__Message__Group__1__Impl : ( 'Message' ) ;
+    // InternalRoom.g:9983:1: rule__Message__Group__1__Impl : ( 'Message' ) ;
     public final void rule__Message__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9788:1: ( ( 'Message' ) )
-            // InternalRoom.g:9789:1: ( 'Message' )
+            // InternalRoom.g:9987:1: ( ( 'Message' ) )
+            // InternalRoom.g:9988:1: ( 'Message' )
             {
-            // InternalRoom.g:9789:1: ( 'Message' )
-            // InternalRoom.g:9790:1: 'Message'
+            // InternalRoom.g:9988:1: ( 'Message' )
+            // InternalRoom.g:9989:1: 'Message'
             {
              before(grammarAccess.getMessageAccess().getMessageKeyword_1()); 
             match(input,25,FOLLOW_2); 
@@ -28183,16 +28751,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__2"
-    // InternalRoom.g:9803:1: rule__Message__Group__2 : rule__Message__Group__2__Impl rule__Message__Group__3 ;
+    // InternalRoom.g:10002:1: rule__Message__Group__2 : rule__Message__Group__2__Impl rule__Message__Group__3 ;
     public final void rule__Message__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9807:1: ( rule__Message__Group__2__Impl rule__Message__Group__3 )
-            // InternalRoom.g:9808:2: rule__Message__Group__2__Impl rule__Message__Group__3
+            // InternalRoom.g:10006:1: ( rule__Message__Group__2__Impl rule__Message__Group__3 )
+            // InternalRoom.g:10007:2: rule__Message__Group__2__Impl rule__Message__Group__3
             {
-            pushFollow(FOLLOW_33);
+            pushFollow(FOLLOW_47);
             rule__Message__Group__2__Impl();
 
             state._fsp--;
@@ -28221,21 +28789,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__2__Impl"
-    // InternalRoom.g:9815:1: rule__Message__Group__2__Impl : ( ( rule__Message__NameAssignment_2 ) ) ;
+    // InternalRoom.g:10014:1: rule__Message__Group__2__Impl : ( ( rule__Message__NameAssignment_2 ) ) ;
     public final void rule__Message__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9819:1: ( ( ( rule__Message__NameAssignment_2 ) ) )
-            // InternalRoom.g:9820:1: ( ( rule__Message__NameAssignment_2 ) )
+            // InternalRoom.g:10018:1: ( ( ( rule__Message__NameAssignment_2 ) ) )
+            // InternalRoom.g:10019:1: ( ( rule__Message__NameAssignment_2 ) )
             {
-            // InternalRoom.g:9820:1: ( ( rule__Message__NameAssignment_2 ) )
-            // InternalRoom.g:9821:1: ( rule__Message__NameAssignment_2 )
+            // InternalRoom.g:10019:1: ( ( rule__Message__NameAssignment_2 ) )
+            // InternalRoom.g:10020:1: ( rule__Message__NameAssignment_2 )
             {
              before(grammarAccess.getMessageAccess().getNameAssignment_2()); 
-            // InternalRoom.g:9822:1: ( rule__Message__NameAssignment_2 )
-            // InternalRoom.g:9822:2: rule__Message__NameAssignment_2
+            // InternalRoom.g:10021:1: ( rule__Message__NameAssignment_2 )
+            // InternalRoom.g:10021:2: rule__Message__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Message__NameAssignment_2();
@@ -28268,16 +28836,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__3"
-    // InternalRoom.g:9832:1: rule__Message__Group__3 : rule__Message__Group__3__Impl rule__Message__Group__4 ;
+    // InternalRoom.g:10031:1: rule__Message__Group__3 : rule__Message__Group__3__Impl rule__Message__Group__4 ;
     public final void rule__Message__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9836:1: ( rule__Message__Group__3__Impl rule__Message__Group__4 )
-            // InternalRoom.g:9837:2: rule__Message__Group__3__Impl rule__Message__Group__4
+            // InternalRoom.g:10035:1: ( rule__Message__Group__3__Impl rule__Message__Group__4 )
+            // InternalRoom.g:10036:2: rule__Message__Group__3__Impl rule__Message__Group__4
             {
-            pushFollow(FOLLOW_34);
+            pushFollow(FOLLOW_47);
             rule__Message__Group__3__Impl();
 
             state._fsp--;
@@ -28306,21 +28874,42 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__3__Impl"
-    // InternalRoom.g:9844:1: rule__Message__Group__3__Impl : ( '(' ) ;
+    // InternalRoom.g:10043:1: rule__Message__Group__3__Impl : ( ( rule__Message__Group_3__0 )? ) ;
     public final void rule__Message__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9848:1: ( ( '(' ) )
-            // InternalRoom.g:9849:1: ( '(' )
+            // InternalRoom.g:10047:1: ( ( ( rule__Message__Group_3__0 )? ) )
+            // InternalRoom.g:10048:1: ( ( rule__Message__Group_3__0 )? )
             {
-            // InternalRoom.g:9849:1: ( '(' )
-            // InternalRoom.g:9850:1: '('
+            // InternalRoom.g:10048:1: ( ( rule__Message__Group_3__0 )? )
+            // InternalRoom.g:10049:1: ( rule__Message__Group_3__0 )?
             {
-             before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); 
-            match(input,50,FOLLOW_2); 
-             after(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); 
+             before(grammarAccess.getMessageAccess().getGroup_3()); 
+            // InternalRoom.g:10050:1: ( rule__Message__Group_3__0 )?
+            int alt108=2;
+            int LA108_0 = input.LA(1);
+
+            if ( (LA108_0==50) ) {
+                alt108=1;
+            }
+            switch (alt108) {
+                case 1 :
+                    // InternalRoom.g:10050:2: rule__Message__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__Message__Group_3__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMessageAccess().getGroup_3()); 
 
             }
 
@@ -28343,16 +28932,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__4"
-    // InternalRoom.g:9863:1: rule__Message__Group__4 : rule__Message__Group__4__Impl rule__Message__Group__5 ;
+    // InternalRoom.g:10060:1: rule__Message__Group__4 : rule__Message__Group__4__Impl rule__Message__Group__5 ;
     public final void rule__Message__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9867:1: ( rule__Message__Group__4__Impl rule__Message__Group__5 )
-            // InternalRoom.g:9868:2: rule__Message__Group__4__Impl rule__Message__Group__5
+            // InternalRoom.g:10064:1: ( rule__Message__Group__4__Impl rule__Message__Group__5 )
+            // InternalRoom.g:10065:2: rule__Message__Group__4__Impl rule__Message__Group__5
             {
-            pushFollow(FOLLOW_34);
+            pushFollow(FOLLOW_47);
             rule__Message__Group__4__Impl();
 
             state._fsp--;
@@ -28381,42 +28970,49 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__4__Impl"
-    // InternalRoom.g:9875:1: rule__Message__Group__4__Impl : ( ( rule__Message__DataAssignment_4 )? ) ;
+    // InternalRoom.g:10072:1: rule__Message__Group__4__Impl : ( ( rule__Message__AnnotationsAssignment_4 )* ) ;
     public final void rule__Message__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9879:1: ( ( ( rule__Message__DataAssignment_4 )? ) )
-            // InternalRoom.g:9880:1: ( ( rule__Message__DataAssignment_4 )? )
+            // InternalRoom.g:10076:1: ( ( ( rule__Message__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:10077:1: ( ( rule__Message__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:9880:1: ( ( rule__Message__DataAssignment_4 )? )
-            // InternalRoom.g:9881:1: ( rule__Message__DataAssignment_4 )?
+            // InternalRoom.g:10077:1: ( ( rule__Message__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:10078:1: ( rule__Message__AnnotationsAssignment_4 )*
             {
-             before(grammarAccess.getMessageAccess().getDataAssignment_4()); 
-            // InternalRoom.g:9882:1: ( rule__Message__DataAssignment_4 )?
-            int alt106=2;
-            int LA106_0 = input.LA(1);
+             before(grammarAccess.getMessageAccess().getAnnotationsAssignment_4()); 
+            // InternalRoom.g:10079:1: ( rule__Message__AnnotationsAssignment_4 )*
+            loop109:
+            do {
+                int alt109=2;
+                int LA109_0 = input.LA(1);
 
-            if ( (LA106_0==RULE_ID) ) {
-                alt106=1;
-            }
-            switch (alt106) {
-                case 1 :
-                    // InternalRoom.g:9882:2: rule__Message__DataAssignment_4
-                    {
-                    pushFollow(FOLLOW_2);
-                    rule__Message__DataAssignment_4();
+                if ( (LA109_0==121) ) {
+                    alt109=1;
+                }
 
-                    state._fsp--;
 
+                switch (alt109) {
+            	case 1 :
+            	    // InternalRoom.g:10079:2: rule__Message__AnnotationsAssignment_4
+            	    {
+            	    pushFollow(FOLLOW_25);
+            	    rule__Message__AnnotationsAssignment_4();
 
-                    }
-                    break;
+            	    state._fsp--;
 
-            }
 
-             after(grammarAccess.getMessageAccess().getDataAssignment_4()); 
+            	    }
+            	    break;
+
+            	default :
+            	    break loop109;
+                }
+            } while (true);
+
+             after(grammarAccess.getMessageAccess().getAnnotationsAssignment_4()); 
 
             }
 
@@ -28439,22 +29035,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__5"
-    // InternalRoom.g:9892:1: rule__Message__Group__5 : rule__Message__Group__5__Impl rule__Message__Group__6 ;
+    // InternalRoom.g:10089:1: rule__Message__Group__5 : rule__Message__Group__5__Impl ;
     public final void rule__Message__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9896:1: ( rule__Message__Group__5__Impl rule__Message__Group__6 )
-            // InternalRoom.g:9897:2: rule__Message__Group__5__Impl rule__Message__Group__6
+            // InternalRoom.g:10093:1: ( rule__Message__Group__5__Impl )
+            // InternalRoom.g:10094:2: rule__Message__Group__5__Impl
             {
-            pushFollow(FOLLOW_47);
-            rule__Message__Group__5__Impl();
-
-            state._fsp--;
-
             pushFollow(FOLLOW_2);
-            rule__Message__Group__6();
+            rule__Message__Group__5__Impl();
 
             state._fsp--;
 
@@ -28477,21 +29068,42 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__5__Impl"
-    // InternalRoom.g:9904:1: rule__Message__Group__5__Impl : ( ')' ) ;
+    // InternalRoom.g:10100:1: rule__Message__Group__5__Impl : ( ( rule__Message__DocuAssignment_5 )? ) ;
     public final void rule__Message__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9908:1: ( ( ')' ) )
-            // InternalRoom.g:9909:1: ( ')' )
+            // InternalRoom.g:10104:1: ( ( ( rule__Message__DocuAssignment_5 )? ) )
+            // InternalRoom.g:10105:1: ( ( rule__Message__DocuAssignment_5 )? )
             {
-            // InternalRoom.g:9909:1: ( ')' )
-            // InternalRoom.g:9910:1: ')'
+            // InternalRoom.g:10105:1: ( ( rule__Message__DocuAssignment_5 )? )
+            // InternalRoom.g:10106:1: ( rule__Message__DocuAssignment_5 )?
             {
-             before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); 
-            match(input,51,FOLLOW_2); 
-             after(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); 
+             before(grammarAccess.getMessageAccess().getDocuAssignment_5()); 
+            // InternalRoom.g:10107:1: ( rule__Message__DocuAssignment_5 )?
+            int alt110=2;
+            int LA110_0 = input.LA(1);
+
+            if ( (LA110_0==62) ) {
+                alt110=1;
+            }
+            switch (alt110) {
+                case 1 :
+                    // InternalRoom.g:10107:2: rule__Message__DocuAssignment_5
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__Message__DocuAssignment_5();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMessageAccess().getDocuAssignment_5()); 
 
             }
 
@@ -28513,23 +29125,23 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__Message__Group__5__Impl"
 
 
-    // $ANTLR start "rule__Message__Group__6"
-    // InternalRoom.g:9923:1: rule__Message__Group__6 : rule__Message__Group__6__Impl rule__Message__Group__7 ;
-    public final void rule__Message__Group__6() throws RecognitionException {
+    // $ANTLR start "rule__Message__Group_3__0"
+    // InternalRoom.g:10129:1: rule__Message__Group_3__0 : rule__Message__Group_3__0__Impl rule__Message__Group_3__1 ;
+    public final void rule__Message__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9927:1: ( rule__Message__Group__6__Impl rule__Message__Group__7 )
-            // InternalRoom.g:9928:2: rule__Message__Group__6__Impl rule__Message__Group__7
+            // InternalRoom.g:10133:1: ( rule__Message__Group_3__0__Impl rule__Message__Group_3__1 )
+            // InternalRoom.g:10134:2: rule__Message__Group_3__0__Impl rule__Message__Group_3__1
             {
-            pushFollow(FOLLOW_47);
-            rule__Message__Group__6__Impl();
+            pushFollow(FOLLOW_34);
+            rule__Message__Group_3__0__Impl();
 
             state._fsp--;
 
             pushFollow(FOLLOW_2);
-            rule__Message__Group__7();
+            rule__Message__Group_3__1();
 
             state._fsp--;
 
@@ -28548,53 +29160,25 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__Group__6"
+    // $ANTLR end "rule__Message__Group_3__0"
 
 
-    // $ANTLR start "rule__Message__Group__6__Impl"
-    // InternalRoom.g:9935:1: rule__Message__Group__6__Impl : ( ( rule__Message__AnnotationsAssignment_6 )* ) ;
-    public final void rule__Message__Group__6__Impl() throws RecognitionException {
+    // $ANTLR start "rule__Message__Group_3__0__Impl"
+    // InternalRoom.g:10141:1: rule__Message__Group_3__0__Impl : ( '(' ) ;
+    public final void rule__Message__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9939:1: ( ( ( rule__Message__AnnotationsAssignment_6 )* ) )
-            // InternalRoom.g:9940:1: ( ( rule__Message__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:10145:1: ( ( '(' ) )
+            // InternalRoom.g:10146:1: ( '(' )
             {
-            // InternalRoom.g:9940:1: ( ( rule__Message__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:9941:1: ( rule__Message__AnnotationsAssignment_6 )*
+            // InternalRoom.g:10146:1: ( '(' )
+            // InternalRoom.g:10147:1: '('
             {
-             before(grammarAccess.getMessageAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:9942:1: ( rule__Message__AnnotationsAssignment_6 )*
-            loop107:
-            do {
-                int alt107=2;
-                int LA107_0 = input.LA(1);
-
-                if ( (LA107_0==121) ) {
-                    alt107=1;
-                }
-
-
-                switch (alt107) {
-            	case 1 :
-            	    // InternalRoom.g:9942:2: rule__Message__AnnotationsAssignment_6
-            	    {
-            	    pushFollow(FOLLOW_25);
-            	    rule__Message__AnnotationsAssignment_6();
-
-            	    state._fsp--;
-
-
-            	    }
-            	    break;
-
-            	default :
-            	    break loop107;
-                }
-            } while (true);
-
-             after(grammarAccess.getMessageAccess().getAnnotationsAssignment_6()); 
+             before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0()); 
+            match(input,50,FOLLOW_2); 
+             after(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0()); 
 
             }
 
@@ -28613,21 +29197,26 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__Group__6__Impl"
+    // $ANTLR end "rule__Message__Group_3__0__Impl"
 
 
-    // $ANTLR start "rule__Message__Group__7"
-    // InternalRoom.g:9952:1: rule__Message__Group__7 : rule__Message__Group__7__Impl ;
-    public final void rule__Message__Group__7() throws RecognitionException {
+    // $ANTLR start "rule__Message__Group_3__1"
+    // InternalRoom.g:10160:1: rule__Message__Group_3__1 : rule__Message__Group_3__1__Impl rule__Message__Group_3__2 ;
+    public final void rule__Message__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9956:1: ( rule__Message__Group__7__Impl )
-            // InternalRoom.g:9957:2: rule__Message__Group__7__Impl
+            // InternalRoom.g:10164:1: ( rule__Message__Group_3__1__Impl rule__Message__Group_3__2 )
+            // InternalRoom.g:10165:2: rule__Message__Group_3__1__Impl rule__Message__Group_3__2
             {
+            pushFollow(FOLLOW_34);
+            rule__Message__Group_3__1__Impl();
+
+            state._fsp--;
+
             pushFollow(FOLLOW_2);
-            rule__Message__Group__7__Impl();
+            rule__Message__Group_3__2();
 
             state._fsp--;
 
@@ -28646,36 +29235,36 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__Group__7"
+    // $ANTLR end "rule__Message__Group_3__1"
 
 
-    // $ANTLR start "rule__Message__Group__7__Impl"
-    // InternalRoom.g:9963:1: rule__Message__Group__7__Impl : ( ( rule__Message__DocuAssignment_7 )? ) ;
-    public final void rule__Message__Group__7__Impl() throws RecognitionException {
+    // $ANTLR start "rule__Message__Group_3__1__Impl"
+    // InternalRoom.g:10172:1: rule__Message__Group_3__1__Impl : ( ( rule__Message__DataAssignment_3_1 )? ) ;
+    public final void rule__Message__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9967:1: ( ( ( rule__Message__DocuAssignment_7 )? ) )
-            // InternalRoom.g:9968:1: ( ( rule__Message__DocuAssignment_7 )? )
+            // InternalRoom.g:10176:1: ( ( ( rule__Message__DataAssignment_3_1 )? ) )
+            // InternalRoom.g:10177:1: ( ( rule__Message__DataAssignment_3_1 )? )
             {
-            // InternalRoom.g:9968:1: ( ( rule__Message__DocuAssignment_7 )? )
-            // InternalRoom.g:9969:1: ( rule__Message__DocuAssignment_7 )?
+            // InternalRoom.g:10177:1: ( ( rule__Message__DataAssignment_3_1 )? )
+            // InternalRoom.g:10178:1: ( rule__Message__DataAssignment_3_1 )?
             {
-             before(grammarAccess.getMessageAccess().getDocuAssignment_7()); 
-            // InternalRoom.g:9970:1: ( rule__Message__DocuAssignment_7 )?
-            int alt108=2;
-            int LA108_0 = input.LA(1);
+             before(grammarAccess.getMessageAccess().getDataAssignment_3_1()); 
+            // InternalRoom.g:10179:1: ( rule__Message__DataAssignment_3_1 )?
+            int alt111=2;
+            int LA111_0 = input.LA(1);
 
-            if ( (LA108_0==62) ) {
-                alt108=1;
+            if ( (LA111_0==RULE_ID) ) {
+                alt111=1;
             }
-            switch (alt108) {
+            switch (alt111) {
                 case 1 :
-                    // InternalRoom.g:9970:2: rule__Message__DocuAssignment_7
+                    // InternalRoom.g:10179:2: rule__Message__DataAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
-                    rule__Message__DocuAssignment_7();
+                    rule__Message__DataAssignment_3_1();
 
                     state._fsp--;
 
@@ -28685,7 +29274,77 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             }
 
-             after(grammarAccess.getMessageAccess().getDocuAssignment_7()); 
+             after(grammarAccess.getMessageAccess().getDataAssignment_3_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Message__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__Message__Group_3__2"
+    // InternalRoom.g:10189:1: rule__Message__Group_3__2 : rule__Message__Group_3__2__Impl ;
+    public final void rule__Message__Group_3__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:10193:1: ( rule__Message__Group_3__2__Impl )
+            // InternalRoom.g:10194:2: rule__Message__Group_3__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__Message__Group_3__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Message__Group_3__2"
+
+
+    // $ANTLR start "rule__Message__Group_3__2__Impl"
+    // InternalRoom.g:10200:1: rule__Message__Group_3__2__Impl : ( ')' ) ;
+    public final void rule__Message__Group_3__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:10204:1: ( ( ')' ) )
+            // InternalRoom.g:10205:1: ( ')' )
+            {
+            // InternalRoom.g:10205:1: ( ')' )
+            // InternalRoom.g:10206:1: ')'
+            {
+             before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2()); 
+            match(input,51,FOLLOW_2); 
+             after(grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2()); 
 
             }
 
@@ -28704,18 +29363,18 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__Group__7__Impl"
+    // $ANTLR end "rule__Message__Group_3__2__Impl"
 
 
     // $ANTLR start "rule__PortClass__Group__0"
-    // InternalRoom.g:9996:1: rule__PortClass__Group__0 : rule__PortClass__Group__0__Impl rule__PortClass__Group__1 ;
+    // InternalRoom.g:10225:1: rule__PortClass__Group__0 : rule__PortClass__Group__0__Impl rule__PortClass__Group__1 ;
     public final void rule__PortClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10000:1: ( rule__PortClass__Group__0__Impl rule__PortClass__Group__1 )
-            // InternalRoom.g:10001:2: rule__PortClass__Group__0__Impl rule__PortClass__Group__1
+            // InternalRoom.g:10229:1: ( rule__PortClass__Group__0__Impl rule__PortClass__Group__1 )
+            // InternalRoom.g:10230:2: rule__PortClass__Group__0__Impl rule__PortClass__Group__1
             {
             pushFollow(FOLLOW_40);
             rule__PortClass__Group__0__Impl();
@@ -28746,21 +29405,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__0__Impl"
-    // InternalRoom.g:10008:1: rule__PortClass__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:10237:1: rule__PortClass__Group__0__Impl : ( () ) ;
     public final void rule__PortClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10012:1: ( ( () ) )
-            // InternalRoom.g:10013:1: ( () )
+            // InternalRoom.g:10241:1: ( ( () ) )
+            // InternalRoom.g:10242:1: ( () )
             {
-            // InternalRoom.g:10013:1: ( () )
-            // InternalRoom.g:10014:1: ()
+            // InternalRoom.g:10242:1: ( () )
+            // InternalRoom.g:10243:1: ()
             {
              before(grammarAccess.getPortClassAccess().getPortClassAction_0()); 
-            // InternalRoom.g:10015:1: ()
-            // InternalRoom.g:10017:1: 
+            // InternalRoom.g:10244:1: ()
+            // InternalRoom.g:10246:1: 
             {
             }
 
@@ -28783,14 +29442,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__1"
-    // InternalRoom.g:10027:1: rule__PortClass__Group__1 : rule__PortClass__Group__1__Impl rule__PortClass__Group__2 ;
+    // InternalRoom.g:10256:1: rule__PortClass__Group__1 : rule__PortClass__Group__1__Impl rule__PortClass__Group__2 ;
     public final void rule__PortClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10031:1: ( rule__PortClass__Group__1__Impl rule__PortClass__Group__2 )
-            // InternalRoom.g:10032:2: rule__PortClass__Group__1__Impl rule__PortClass__Group__2
+            // InternalRoom.g:10260:1: ( rule__PortClass__Group__1__Impl rule__PortClass__Group__2 )
+            // InternalRoom.g:10261:2: rule__PortClass__Group__1__Impl rule__PortClass__Group__2
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__1__Impl();
@@ -28821,17 +29480,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__1__Impl"
-    // InternalRoom.g:10039:1: rule__PortClass__Group__1__Impl : ( '{' ) ;
+    // InternalRoom.g:10268:1: rule__PortClass__Group__1__Impl : ( '{' ) ;
     public final void rule__PortClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10043:1: ( ( '{' ) )
-            // InternalRoom.g:10044:1: ( '{' )
+            // InternalRoom.g:10272:1: ( ( '{' ) )
+            // InternalRoom.g:10273:1: ( '{' )
             {
-            // InternalRoom.g:10044:1: ( '{' )
-            // InternalRoom.g:10045:1: '{'
+            // InternalRoom.g:10273:1: ( '{' )
+            // InternalRoom.g:10274:1: '{'
             {
              before(grammarAccess.getPortClassAccess().getLeftCurlyBracketKeyword_1()); 
             match(input,44,FOLLOW_2); 
@@ -28858,14 +29517,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__2"
-    // InternalRoom.g:10058:1: rule__PortClass__Group__2 : rule__PortClass__Group__2__Impl rule__PortClass__Group__3 ;
+    // InternalRoom.g:10287:1: rule__PortClass__Group__2 : rule__PortClass__Group__2__Impl rule__PortClass__Group__3 ;
     public final void rule__PortClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10062:1: ( rule__PortClass__Group__2__Impl rule__PortClass__Group__3 )
-            // InternalRoom.g:10063:2: rule__PortClass__Group__2__Impl rule__PortClass__Group__3
+            // InternalRoom.g:10291:1: ( rule__PortClass__Group__2__Impl rule__PortClass__Group__3 )
+            // InternalRoom.g:10292:2: rule__PortClass__Group__2__Impl rule__PortClass__Group__3
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__2__Impl();
@@ -28896,29 +29555,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__2__Impl"
-    // InternalRoom.g:10070:1: rule__PortClass__Group__2__Impl : ( ( rule__PortClass__Group_2__0 )? ) ;
+    // InternalRoom.g:10299:1: rule__PortClass__Group__2__Impl : ( ( rule__PortClass__Group_2__0 )? ) ;
     public final void rule__PortClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10074:1: ( ( ( rule__PortClass__Group_2__0 )? ) )
-            // InternalRoom.g:10075:1: ( ( rule__PortClass__Group_2__0 )? )
+            // InternalRoom.g:10303:1: ( ( ( rule__PortClass__Group_2__0 )? ) )
+            // InternalRoom.g:10304:1: ( ( rule__PortClass__Group_2__0 )? )
             {
-            // InternalRoom.g:10075:1: ( ( rule__PortClass__Group_2__0 )? )
-            // InternalRoom.g:10076:1: ( rule__PortClass__Group_2__0 )?
+            // InternalRoom.g:10304:1: ( ( rule__PortClass__Group_2__0 )? )
+            // InternalRoom.g:10305:1: ( rule__PortClass__Group_2__0 )?
             {
              before(grammarAccess.getPortClassAccess().getGroup_2()); 
-            // InternalRoom.g:10077:1: ( rule__PortClass__Group_2__0 )?
-            int alt109=2;
-            int LA109_0 = input.LA(1);
+            // InternalRoom.g:10306:1: ( rule__PortClass__Group_2__0 )?
+            int alt112=2;
+            int LA112_0 = input.LA(1);
 
-            if ( (LA109_0==72) ) {
-                alt109=1;
+            if ( (LA112_0==72) ) {
+                alt112=1;
             }
-            switch (alt109) {
+            switch (alt112) {
                 case 1 :
-                    // InternalRoom.g:10077:2: rule__PortClass__Group_2__0
+                    // InternalRoom.g:10306:2: rule__PortClass__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__Group_2__0();
@@ -28954,14 +29613,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__3"
-    // InternalRoom.g:10087:1: rule__PortClass__Group__3 : rule__PortClass__Group__3__Impl rule__PortClass__Group__4 ;
+    // InternalRoom.g:10316:1: rule__PortClass__Group__3 : rule__PortClass__Group__3__Impl rule__PortClass__Group__4 ;
     public final void rule__PortClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10091:1: ( rule__PortClass__Group__3__Impl rule__PortClass__Group__4 )
-            // InternalRoom.g:10092:2: rule__PortClass__Group__3__Impl rule__PortClass__Group__4
+            // InternalRoom.g:10320:1: ( rule__PortClass__Group__3__Impl rule__PortClass__Group__4 )
+            // InternalRoom.g:10321:2: rule__PortClass__Group__3__Impl rule__PortClass__Group__4
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__3__Impl();
@@ -28992,33 +29651,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__3__Impl"
-    // InternalRoom.g:10099:1: rule__PortClass__Group__3__Impl : ( ( rule__PortClass__Alternatives_3 )* ) ;
+    // InternalRoom.g:10328:1: rule__PortClass__Group__3__Impl : ( ( rule__PortClass__Alternatives_3 )* ) ;
     public final void rule__PortClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10103:1: ( ( ( rule__PortClass__Alternatives_3 )* ) )
-            // InternalRoom.g:10104:1: ( ( rule__PortClass__Alternatives_3 )* )
+            // InternalRoom.g:10332:1: ( ( ( rule__PortClass__Alternatives_3 )* ) )
+            // InternalRoom.g:10333:1: ( ( rule__PortClass__Alternatives_3 )* )
             {
-            // InternalRoom.g:10104:1: ( ( rule__PortClass__Alternatives_3 )* )
-            // InternalRoom.g:10105:1: ( rule__PortClass__Alternatives_3 )*
+            // InternalRoom.g:10333:1: ( ( rule__PortClass__Alternatives_3 )* )
+            // InternalRoom.g:10334:1: ( rule__PortClass__Alternatives_3 )*
             {
              before(grammarAccess.getPortClassAccess().getAlternatives_3()); 
-            // InternalRoom.g:10106:1: ( rule__PortClass__Alternatives_3 )*
-            loop110:
+            // InternalRoom.g:10335:1: ( rule__PortClass__Alternatives_3 )*
+            loop113:
             do {
-                int alt110=2;
-                int LA110_0 = input.LA(1);
+                int alt113=2;
+                int LA113_0 = input.LA(1);
 
-                if ( (LA110_0==61||LA110_0==64||LA110_0==73) ) {
-                    alt110=1;
+                if ( (LA113_0==61||LA113_0==64||LA113_0==73) ) {
+                    alt113=1;
                 }
 
 
-                switch (alt110) {
+                switch (alt113) {
             	case 1 :
-            	    // InternalRoom.g:10106:2: rule__PortClass__Alternatives_3
+            	    // InternalRoom.g:10335:2: rule__PortClass__Alternatives_3
             	    {
             	    pushFollow(FOLLOW_49);
             	    rule__PortClass__Alternatives_3();
@@ -29030,7 +29689,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop110;
+            	    break loop113;
                 }
             } while (true);
 
@@ -29057,14 +29716,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__4"
-    // InternalRoom.g:10116:1: rule__PortClass__Group__4 : rule__PortClass__Group__4__Impl ;
+    // InternalRoom.g:10345:1: rule__PortClass__Group__4 : rule__PortClass__Group__4__Impl ;
     public final void rule__PortClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10120:1: ( rule__PortClass__Group__4__Impl )
-            // InternalRoom.g:10121:2: rule__PortClass__Group__4__Impl
+            // InternalRoom.g:10349:1: ( rule__PortClass__Group__4__Impl )
+            // InternalRoom.g:10350:2: rule__PortClass__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__Group__4__Impl();
@@ -29090,17 +29749,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__4__Impl"
-    // InternalRoom.g:10127:1: rule__PortClass__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:10356:1: rule__PortClass__Group__4__Impl : ( '}' ) ;
     public final void rule__PortClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10131:1: ( ( '}' ) )
-            // InternalRoom.g:10132:1: ( '}' )
+            // InternalRoom.g:10360:1: ( ( '}' ) )
+            // InternalRoom.g:10361:1: ( '}' )
             {
-            // InternalRoom.g:10132:1: ( '}' )
-            // InternalRoom.g:10133:1: '}'
+            // InternalRoom.g:10361:1: ( '}' )
+            // InternalRoom.g:10362:1: '}'
             {
              before(grammarAccess.getPortClassAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -29127,14 +29786,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group_2__0"
-    // InternalRoom.g:10156:1: rule__PortClass__Group_2__0 : rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1 ;
+    // InternalRoom.g:10385:1: rule__PortClass__Group_2__0 : rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1 ;
     public final void rule__PortClass__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10160:1: ( rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1 )
-            // InternalRoom.g:10161:2: rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1
+            // InternalRoom.g:10389:1: ( rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1 )
+            // InternalRoom.g:10390:2: rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1
             {
             pushFollow(FOLLOW_27);
             rule__PortClass__Group_2__0__Impl();
@@ -29165,17 +29824,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group_2__0__Impl"
-    // InternalRoom.g:10168:1: rule__PortClass__Group_2__0__Impl : ( 'usercode' ) ;
+    // InternalRoom.g:10397:1: rule__PortClass__Group_2__0__Impl : ( 'usercode' ) ;
     public final void rule__PortClass__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10172:1: ( ( 'usercode' ) )
-            // InternalRoom.g:10173:1: ( 'usercode' )
+            // InternalRoom.g:10401:1: ( ( 'usercode' ) )
+            // InternalRoom.g:10402:1: ( 'usercode' )
             {
-            // InternalRoom.g:10173:1: ( 'usercode' )
-            // InternalRoom.g:10174:1: 'usercode'
+            // InternalRoom.g:10402:1: ( 'usercode' )
+            // InternalRoom.g:10403:1: 'usercode'
             {
              before(grammarAccess.getPortClassAccess().getUsercodeKeyword_2_0()); 
             match(input,72,FOLLOW_2); 
@@ -29202,14 +29861,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group_2__1"
-    // InternalRoom.g:10187:1: rule__PortClass__Group_2__1 : rule__PortClass__Group_2__1__Impl ;
+    // InternalRoom.g:10416:1: rule__PortClass__Group_2__1 : rule__PortClass__Group_2__1__Impl ;
     public final void rule__PortClass__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10191:1: ( rule__PortClass__Group_2__1__Impl )
-            // InternalRoom.g:10192:2: rule__PortClass__Group_2__1__Impl
+            // InternalRoom.g:10420:1: ( rule__PortClass__Group_2__1__Impl )
+            // InternalRoom.g:10421:2: rule__PortClass__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__Group_2__1__Impl();
@@ -29235,21 +29894,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group_2__1__Impl"
-    // InternalRoom.g:10198:1: rule__PortClass__Group_2__1__Impl : ( ( rule__PortClass__UserCodeAssignment_2_1 ) ) ;
+    // InternalRoom.g:10427:1: rule__PortClass__Group_2__1__Impl : ( ( rule__PortClass__UserCodeAssignment_2_1 ) ) ;
     public final void rule__PortClass__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10202:1: ( ( ( rule__PortClass__UserCodeAssignment_2_1 ) ) )
-            // InternalRoom.g:10203:1: ( ( rule__PortClass__UserCodeAssignment_2_1 ) )
+            // InternalRoom.g:10431:1: ( ( ( rule__PortClass__UserCodeAssignment_2_1 ) ) )
+            // InternalRoom.g:10432:1: ( ( rule__PortClass__UserCodeAssignment_2_1 ) )
             {
-            // InternalRoom.g:10203:1: ( ( rule__PortClass__UserCodeAssignment_2_1 ) )
-            // InternalRoom.g:10204:1: ( rule__PortClass__UserCodeAssignment_2_1 )
+            // InternalRoom.g:10432:1: ( ( rule__PortClass__UserCodeAssignment_2_1 ) )
+            // InternalRoom.g:10433:1: ( rule__PortClass__UserCodeAssignment_2_1 )
             {
              before(grammarAccess.getPortClassAccess().getUserCodeAssignment_2_1()); 
-            // InternalRoom.g:10205:1: ( rule__PortClass__UserCodeAssignment_2_1 )
-            // InternalRoom.g:10205:2: rule__PortClass__UserCodeAssignment_2_1
+            // InternalRoom.g:10434:1: ( rule__PortClass__UserCodeAssignment_2_1 )
+            // InternalRoom.g:10434:2: rule__PortClass__UserCodeAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__UserCodeAssignment_2_1();
@@ -29282,14 +29941,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__0"
-    // InternalRoom.g:10219:1: rule__InMessageHandler__Group__0 : rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1 ;
+    // InternalRoom.g:10448:1: rule__InMessageHandler__Group__0 : rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1 ;
     public final void rule__InMessageHandler__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10223:1: ( rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1 )
-            // InternalRoom.g:10224:2: rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1
+            // InternalRoom.g:10452:1: ( rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1 )
+            // InternalRoom.g:10453:2: rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1
             {
             pushFollow(FOLLOW_50);
             rule__InMessageHandler__Group__0__Impl();
@@ -29320,17 +29979,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__0__Impl"
-    // InternalRoom.g:10231:1: rule__InMessageHandler__Group__0__Impl : ( 'handle' ) ;
+    // InternalRoom.g:10460:1: rule__InMessageHandler__Group__0__Impl : ( 'handle' ) ;
     public final void rule__InMessageHandler__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10235:1: ( ( 'handle' ) )
-            // InternalRoom.g:10236:1: ( 'handle' )
+            // InternalRoom.g:10464:1: ( ( 'handle' ) )
+            // InternalRoom.g:10465:1: ( 'handle' )
             {
-            // InternalRoom.g:10236:1: ( 'handle' )
-            // InternalRoom.g:10237:1: 'handle'
+            // InternalRoom.g:10465:1: ( 'handle' )
+            // InternalRoom.g:10466:1: 'handle'
             {
              before(grammarAccess.getInMessageHandlerAccess().getHandleKeyword_0()); 
             match(input,73,FOLLOW_2); 
@@ -29357,14 +30016,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__1"
-    // InternalRoom.g:10250:1: rule__InMessageHandler__Group__1 : rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2 ;
+    // InternalRoom.g:10479:1: rule__InMessageHandler__Group__1 : rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2 ;
     public final void rule__InMessageHandler__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10254:1: ( rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2 )
-            // InternalRoom.g:10255:2: rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2
+            // InternalRoom.g:10483:1: ( rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2 )
+            // InternalRoom.g:10484:2: rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__InMessageHandler__Group__1__Impl();
@@ -29395,17 +30054,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__1__Impl"
-    // InternalRoom.g:10262:1: rule__InMessageHandler__Group__1__Impl : ( 'incoming' ) ;
+    // InternalRoom.g:10491:1: rule__InMessageHandler__Group__1__Impl : ( 'incoming' ) ;
     public final void rule__InMessageHandler__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10266:1: ( ( 'incoming' ) )
-            // InternalRoom.g:10267:1: ( 'incoming' )
+            // InternalRoom.g:10495:1: ( ( 'incoming' ) )
+            // InternalRoom.g:10496:1: ( 'incoming' )
             {
-            // InternalRoom.g:10267:1: ( 'incoming' )
-            // InternalRoom.g:10268:1: 'incoming'
+            // InternalRoom.g:10496:1: ( 'incoming' )
+            // InternalRoom.g:10497:1: 'incoming'
             {
              before(grammarAccess.getInMessageHandlerAccess().getIncomingKeyword_1()); 
             match(input,66,FOLLOW_2); 
@@ -29432,14 +30091,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__2"
-    // InternalRoom.g:10281:1: rule__InMessageHandler__Group__2 : rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3 ;
+    // InternalRoom.g:10510:1: rule__InMessageHandler__Group__2 : rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3 ;
     public final void rule__InMessageHandler__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10285:1: ( rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3 )
-            // InternalRoom.g:10286:2: rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3
+            // InternalRoom.g:10514:1: ( rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3 )
+            // InternalRoom.g:10515:2: rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3
             {
             pushFollow(FOLLOW_27);
             rule__InMessageHandler__Group__2__Impl();
@@ -29470,21 +30129,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__2__Impl"
-    // InternalRoom.g:10293:1: rule__InMessageHandler__Group__2__Impl : ( ( rule__InMessageHandler__MsgAssignment_2 ) ) ;
+    // InternalRoom.g:10522:1: rule__InMessageHandler__Group__2__Impl : ( ( rule__InMessageHandler__MsgAssignment_2 ) ) ;
     public final void rule__InMessageHandler__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10297:1: ( ( ( rule__InMessageHandler__MsgAssignment_2 ) ) )
-            // InternalRoom.g:10298:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10526:1: ( ( ( rule__InMessageHandler__MsgAssignment_2 ) ) )
+            // InternalRoom.g:10527:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:10298:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
-            // InternalRoom.g:10299:1: ( rule__InMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10527:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10528:1: ( rule__InMessageHandler__MsgAssignment_2 )
             {
              before(grammarAccess.getInMessageHandlerAccess().getMsgAssignment_2()); 
-            // InternalRoom.g:10300:1: ( rule__InMessageHandler__MsgAssignment_2 )
-            // InternalRoom.g:10300:2: rule__InMessageHandler__MsgAssignment_2
+            // InternalRoom.g:10529:1: ( rule__InMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10529:2: rule__InMessageHandler__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__MsgAssignment_2();
@@ -29517,14 +30176,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__3"
-    // InternalRoom.g:10310:1: rule__InMessageHandler__Group__3 : rule__InMessageHandler__Group__3__Impl ;
+    // InternalRoom.g:10539:1: rule__InMessageHandler__Group__3 : rule__InMessageHandler__Group__3__Impl ;
     public final void rule__InMessageHandler__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10314:1: ( rule__InMessageHandler__Group__3__Impl )
-            // InternalRoom.g:10315:2: rule__InMessageHandler__Group__3__Impl
+            // InternalRoom.g:10543:1: ( rule__InMessageHandler__Group__3__Impl )
+            // InternalRoom.g:10544:2: rule__InMessageHandler__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__Group__3__Impl();
@@ -29550,21 +30209,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__Group__3__Impl"
-    // InternalRoom.g:10321:1: rule__InMessageHandler__Group__3__Impl : ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) ) ;
+    // InternalRoom.g:10550:1: rule__InMessageHandler__Group__3__Impl : ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) ) ;
     public final void rule__InMessageHandler__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10325:1: ( ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) ) )
-            // InternalRoom.g:10326:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10554:1: ( ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) ) )
+            // InternalRoom.g:10555:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
             {
-            // InternalRoom.g:10326:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
-            // InternalRoom.g:10327:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10555:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10556:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
             {
              before(grammarAccess.getInMessageHandlerAccess().getDetailCodeAssignment_3()); 
-            // InternalRoom.g:10328:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
-            // InternalRoom.g:10328:2: rule__InMessageHandler__DetailCodeAssignment_3
+            // InternalRoom.g:10557:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10557:2: rule__InMessageHandler__DetailCodeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__DetailCodeAssignment_3();
@@ -29597,14 +30256,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__0"
-    // InternalRoom.g:10346:1: rule__OutMessageHandler__Group__0 : rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1 ;
+    // InternalRoom.g:10575:1: rule__OutMessageHandler__Group__0 : rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1 ;
     public final void rule__OutMessageHandler__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10350:1: ( rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1 )
-            // InternalRoom.g:10351:2: rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1
+            // InternalRoom.g:10579:1: ( rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1 )
+            // InternalRoom.g:10580:2: rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1
             {
             pushFollow(FOLLOW_51);
             rule__OutMessageHandler__Group__0__Impl();
@@ -29635,17 +30294,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__0__Impl"
-    // InternalRoom.g:10358:1: rule__OutMessageHandler__Group__0__Impl : ( 'handle' ) ;
+    // InternalRoom.g:10587:1: rule__OutMessageHandler__Group__0__Impl : ( 'handle' ) ;
     public final void rule__OutMessageHandler__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10362:1: ( ( 'handle' ) )
-            // InternalRoom.g:10363:1: ( 'handle' )
+            // InternalRoom.g:10591:1: ( ( 'handle' ) )
+            // InternalRoom.g:10592:1: ( 'handle' )
             {
-            // InternalRoom.g:10363:1: ( 'handle' )
-            // InternalRoom.g:10364:1: 'handle'
+            // InternalRoom.g:10592:1: ( 'handle' )
+            // InternalRoom.g:10593:1: 'handle'
             {
              before(grammarAccess.getOutMessageHandlerAccess().getHandleKeyword_0()); 
             match(input,73,FOLLOW_2); 
@@ -29672,14 +30331,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__1"
-    // InternalRoom.g:10377:1: rule__OutMessageHandler__Group__1 : rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2 ;
+    // InternalRoom.g:10606:1: rule__OutMessageHandler__Group__1 : rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2 ;
     public final void rule__OutMessageHandler__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10381:1: ( rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2 )
-            // InternalRoom.g:10382:2: rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2
+            // InternalRoom.g:10610:1: ( rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2 )
+            // InternalRoom.g:10611:2: rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__OutMessageHandler__Group__1__Impl();
@@ -29710,17 +30369,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__1__Impl"
-    // InternalRoom.g:10389:1: rule__OutMessageHandler__Group__1__Impl : ( 'outgoing' ) ;
+    // InternalRoom.g:10618:1: rule__OutMessageHandler__Group__1__Impl : ( 'outgoing' ) ;
     public final void rule__OutMessageHandler__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10393:1: ( ( 'outgoing' ) )
-            // InternalRoom.g:10394:1: ( 'outgoing' )
+            // InternalRoom.g:10622:1: ( ( 'outgoing' ) )
+            // InternalRoom.g:10623:1: ( 'outgoing' )
             {
-            // InternalRoom.g:10394:1: ( 'outgoing' )
-            // InternalRoom.g:10395:1: 'outgoing'
+            // InternalRoom.g:10623:1: ( 'outgoing' )
+            // InternalRoom.g:10624:1: 'outgoing'
             {
              before(grammarAccess.getOutMessageHandlerAccess().getOutgoingKeyword_1()); 
             match(input,67,FOLLOW_2); 
@@ -29747,14 +30406,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__2"
-    // InternalRoom.g:10408:1: rule__OutMessageHandler__Group__2 : rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3 ;
+    // InternalRoom.g:10637:1: rule__OutMessageHandler__Group__2 : rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3 ;
     public final void rule__OutMessageHandler__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10412:1: ( rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3 )
-            // InternalRoom.g:10413:2: rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3
+            // InternalRoom.g:10641:1: ( rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3 )
+            // InternalRoom.g:10642:2: rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3
             {
             pushFollow(FOLLOW_27);
             rule__OutMessageHandler__Group__2__Impl();
@@ -29785,21 +30444,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__2__Impl"
-    // InternalRoom.g:10420:1: rule__OutMessageHandler__Group__2__Impl : ( ( rule__OutMessageHandler__MsgAssignment_2 ) ) ;
+    // InternalRoom.g:10649:1: rule__OutMessageHandler__Group__2__Impl : ( ( rule__OutMessageHandler__MsgAssignment_2 ) ) ;
     public final void rule__OutMessageHandler__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10424:1: ( ( ( rule__OutMessageHandler__MsgAssignment_2 ) ) )
-            // InternalRoom.g:10425:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10653:1: ( ( ( rule__OutMessageHandler__MsgAssignment_2 ) ) )
+            // InternalRoom.g:10654:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:10425:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
-            // InternalRoom.g:10426:1: ( rule__OutMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10654:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10655:1: ( rule__OutMessageHandler__MsgAssignment_2 )
             {
              before(grammarAccess.getOutMessageHandlerAccess().getMsgAssignment_2()); 
-            // InternalRoom.g:10427:1: ( rule__OutMessageHandler__MsgAssignment_2 )
-            // InternalRoom.g:10427:2: rule__OutMessageHandler__MsgAssignment_2
+            // InternalRoom.g:10656:1: ( rule__OutMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10656:2: rule__OutMessageHandler__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__MsgAssignment_2();
@@ -29832,14 +30491,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__3"
-    // InternalRoom.g:10437:1: rule__OutMessageHandler__Group__3 : rule__OutMessageHandler__Group__3__Impl ;
+    // InternalRoom.g:10666:1: rule__OutMessageHandler__Group__3 : rule__OutMessageHandler__Group__3__Impl ;
     public final void rule__OutMessageHandler__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10441:1: ( rule__OutMessageHandler__Group__3__Impl )
-            // InternalRoom.g:10442:2: rule__OutMessageHandler__Group__3__Impl
+            // InternalRoom.g:10670:1: ( rule__OutMessageHandler__Group__3__Impl )
+            // InternalRoom.g:10671:2: rule__OutMessageHandler__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__Group__3__Impl();
@@ -29865,21 +30524,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__Group__3__Impl"
-    // InternalRoom.g:10448:1: rule__OutMessageHandler__Group__3__Impl : ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) ) ;
+    // InternalRoom.g:10677:1: rule__OutMessageHandler__Group__3__Impl : ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) ) ;
     public final void rule__OutMessageHandler__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10452:1: ( ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) ) )
-            // InternalRoom.g:10453:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10681:1: ( ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) ) )
+            // InternalRoom.g:10682:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
             {
-            // InternalRoom.g:10453:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
-            // InternalRoom.g:10454:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10682:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10683:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
             {
              before(grammarAccess.getOutMessageHandlerAccess().getDetailCodeAssignment_3()); 
-            // InternalRoom.g:10455:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
-            // InternalRoom.g:10455:2: rule__OutMessageHandler__DetailCodeAssignment_3
+            // InternalRoom.g:10684:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10684:2: rule__OutMessageHandler__DetailCodeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__DetailCodeAssignment_3();
@@ -29912,14 +30571,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__0"
-    // InternalRoom.g:10473:1: rule__ActorClass__Group__0 : rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1 ;
+    // InternalRoom.g:10702:1: rule__ActorClass__Group__0 : rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1 ;
     public final void rule__ActorClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10477:1: ( rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1 )
-            // InternalRoom.g:10478:2: rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1
+            // InternalRoom.g:10706:1: ( rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1 )
+            // InternalRoom.g:10707:2: rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1
             {
             pushFollow(FOLLOW_52);
             rule__ActorClass__Group__0__Impl();
@@ -29950,21 +30609,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__0__Impl"
-    // InternalRoom.g:10485:1: rule__ActorClass__Group__0__Impl : ( ( rule__ActorClass__UnorderedGroup_0 ) ) ;
+    // InternalRoom.g:10714:1: rule__ActorClass__Group__0__Impl : ( ( rule__ActorClass__UnorderedGroup_0 ) ) ;
     public final void rule__ActorClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10489:1: ( ( ( rule__ActorClass__UnorderedGroup_0 ) ) )
-            // InternalRoom.g:10490:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
+            // InternalRoom.g:10718:1: ( ( ( rule__ActorClass__UnorderedGroup_0 ) ) )
+            // InternalRoom.g:10719:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
             {
-            // InternalRoom.g:10490:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
-            // InternalRoom.g:10491:1: ( rule__ActorClass__UnorderedGroup_0 )
+            // InternalRoom.g:10719:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
+            // InternalRoom.g:10720:1: ( rule__ActorClass__UnorderedGroup_0 )
             {
              before(grammarAccess.getActorClassAccess().getUnorderedGroup_0()); 
-            // InternalRoom.g:10492:1: ( rule__ActorClass__UnorderedGroup_0 )
-            // InternalRoom.g:10492:2: rule__ActorClass__UnorderedGroup_0
+            // InternalRoom.g:10721:1: ( rule__ActorClass__UnorderedGroup_0 )
+            // InternalRoom.g:10721:2: rule__ActorClass__UnorderedGroup_0
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UnorderedGroup_0();
@@ -29997,14 +30656,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__1"
-    // InternalRoom.g:10502:1: rule__ActorClass__Group__1 : rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2 ;
+    // InternalRoom.g:10731:1: rule__ActorClass__Group__1 : rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2 ;
     public final void rule__ActorClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10506:1: ( rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2 )
-            // InternalRoom.g:10507:2: rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2
+            // InternalRoom.g:10735:1: ( rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2 )
+            // InternalRoom.g:10736:2: rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ActorClass__Group__1__Impl();
@@ -30035,17 +30694,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__1__Impl"
-    // InternalRoom.g:10514:1: rule__ActorClass__Group__1__Impl : ( 'ActorClass' ) ;
+    // InternalRoom.g:10743:1: rule__ActorClass__Group__1__Impl : ( 'ActorClass' ) ;
     public final void rule__ActorClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10518:1: ( ( 'ActorClass' ) )
-            // InternalRoom.g:10519:1: ( 'ActorClass' )
+            // InternalRoom.g:10747:1: ( ( 'ActorClass' ) )
+            // InternalRoom.g:10748:1: ( 'ActorClass' )
             {
-            // InternalRoom.g:10519:1: ( 'ActorClass' )
-            // InternalRoom.g:10520:1: 'ActorClass'
+            // InternalRoom.g:10748:1: ( 'ActorClass' )
+            // InternalRoom.g:10749:1: 'ActorClass'
             {
              before(grammarAccess.getActorClassAccess().getActorClassKeyword_1()); 
             match(input,18,FOLLOW_2); 
@@ -30072,14 +30731,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__2"
-    // InternalRoom.g:10533:1: rule__ActorClass__Group__2 : rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3 ;
+    // InternalRoom.g:10762:1: rule__ActorClass__Group__2 : rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3 ;
     public final void rule__ActorClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10537:1: ( rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3 )
-            // InternalRoom.g:10538:2: rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3
+            // InternalRoom.g:10766:1: ( rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3 )
+            // InternalRoom.g:10767:2: rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__2__Impl();
@@ -30110,21 +30769,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__2__Impl"
-    // InternalRoom.g:10545:1: rule__ActorClass__Group__2__Impl : ( ( rule__ActorClass__NameAssignment_2 ) ) ;
+    // InternalRoom.g:10774:1: rule__ActorClass__Group__2__Impl : ( ( rule__ActorClass__NameAssignment_2 ) ) ;
     public final void rule__ActorClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10549:1: ( ( ( rule__ActorClass__NameAssignment_2 ) ) )
-            // InternalRoom.g:10550:1: ( ( rule__ActorClass__NameAssignment_2 ) )
+            // InternalRoom.g:10778:1: ( ( ( rule__ActorClass__NameAssignment_2 ) ) )
+            // InternalRoom.g:10779:1: ( ( rule__ActorClass__NameAssignment_2 ) )
             {
-            // InternalRoom.g:10550:1: ( ( rule__ActorClass__NameAssignment_2 ) )
-            // InternalRoom.g:10551:1: ( rule__ActorClass__NameAssignment_2 )
+            // InternalRoom.g:10779:1: ( ( rule__ActorClass__NameAssignment_2 ) )
+            // InternalRoom.g:10780:1: ( rule__ActorClass__NameAssignment_2 )
             {
              before(grammarAccess.getActorClassAccess().getNameAssignment_2()); 
-            // InternalRoom.g:10552:1: ( rule__ActorClass__NameAssignment_2 )
-            // InternalRoom.g:10552:2: rule__ActorClass__NameAssignment_2
+            // InternalRoom.g:10781:1: ( rule__ActorClass__NameAssignment_2 )
+            // InternalRoom.g:10781:2: rule__ActorClass__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__NameAssignment_2();
@@ -30157,14 +30816,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__3"
-    // InternalRoom.g:10562:1: rule__ActorClass__Group__3 : rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4 ;
+    // InternalRoom.g:10791:1: rule__ActorClass__Group__3 : rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4 ;
     public final void rule__ActorClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10566:1: ( rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4 )
-            // InternalRoom.g:10567:2: rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4
+            // InternalRoom.g:10795:1: ( rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4 )
+            // InternalRoom.g:10796:2: rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__3__Impl();
@@ -30195,29 +30854,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__3__Impl"
-    // InternalRoom.g:10574:1: rule__ActorClass__Group__3__Impl : ( ( rule__ActorClass__DocuAssignment_3 )? ) ;
+    // InternalRoom.g:10803:1: rule__ActorClass__Group__3__Impl : ( ( rule__ActorClass__DocuAssignment_3 )? ) ;
     public final void rule__ActorClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10578:1: ( ( ( rule__ActorClass__DocuAssignment_3 )? ) )
-            // InternalRoom.g:10579:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
+            // InternalRoom.g:10807:1: ( ( ( rule__ActorClass__DocuAssignment_3 )? ) )
+            // InternalRoom.g:10808:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
             {
-            // InternalRoom.g:10579:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
-            // InternalRoom.g:10580:1: ( rule__ActorClass__DocuAssignment_3 )?
+            // InternalRoom.g:10808:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
+            // InternalRoom.g:10809:1: ( rule__ActorClass__DocuAssignment_3 )?
             {
              before(grammarAccess.getActorClassAccess().getDocuAssignment_3()); 
-            // InternalRoom.g:10581:1: ( rule__ActorClass__DocuAssignment_3 )?
-            int alt111=2;
-            int LA111_0 = input.LA(1);
+            // InternalRoom.g:10810:1: ( rule__ActorClass__DocuAssignment_3 )?
+            int alt114=2;
+            int LA114_0 = input.LA(1);
 
-            if ( (LA111_0==62) ) {
-                alt111=1;
+            if ( (LA114_0==62) ) {
+                alt114=1;
             }
-            switch (alt111) {
+            switch (alt114) {
                 case 1 :
-                    // InternalRoom.g:10581:2: rule__ActorClass__DocuAssignment_3
+                    // InternalRoom.g:10810:2: rule__ActorClass__DocuAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__DocuAssignment_3();
@@ -30253,14 +30912,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__4"
-    // InternalRoom.g:10591:1: rule__ActorClass__Group__4 : rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5 ;
+    // InternalRoom.g:10820:1: rule__ActorClass__Group__4 : rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5 ;
     public final void rule__ActorClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10595:1: ( rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5 )
-            // InternalRoom.g:10596:2: rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5
+            // InternalRoom.g:10824:1: ( rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5 )
+            // InternalRoom.g:10825:2: rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__4__Impl();
@@ -30291,29 +30950,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__4__Impl"
-    // InternalRoom.g:10603:1: rule__ActorClass__Group__4__Impl : ( ( rule__ActorClass__Group_4__0 )? ) ;
+    // InternalRoom.g:10832:1: rule__ActorClass__Group__4__Impl : ( ( rule__ActorClass__Group_4__0 )? ) ;
     public final void rule__ActorClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10607:1: ( ( ( rule__ActorClass__Group_4__0 )? ) )
-            // InternalRoom.g:10608:1: ( ( rule__ActorClass__Group_4__0 )? )
+            // InternalRoom.g:10836:1: ( ( ( rule__ActorClass__Group_4__0 )? ) )
+            // InternalRoom.g:10837:1: ( ( rule__ActorClass__Group_4__0 )? )
             {
-            // InternalRoom.g:10608:1: ( ( rule__ActorClass__Group_4__0 )? )
-            // InternalRoom.g:10609:1: ( rule__ActorClass__Group_4__0 )?
+            // InternalRoom.g:10837:1: ( ( rule__ActorClass__Group_4__0 )? )
+            // InternalRoom.g:10838:1: ( rule__ActorClass__Group_4__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_4()); 
-            // InternalRoom.g:10610:1: ( rule__ActorClass__Group_4__0 )?
-            int alt112=2;
-            int LA112_0 = input.LA(1);
+            // InternalRoom.g:10839:1: ( rule__ActorClass__Group_4__0 )?
+            int alt115=2;
+            int LA115_0 = input.LA(1);
 
-            if ( (LA112_0==57) ) {
-                alt112=1;
+            if ( (LA115_0==57) ) {
+                alt115=1;
             }
-            switch (alt112) {
+            switch (alt115) {
                 case 1 :
-                    // InternalRoom.g:10610:2: rule__ActorClass__Group_4__0
+                    // InternalRoom.g:10839:2: rule__ActorClass__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_4__0();
@@ -30349,14 +31008,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__5"
-    // InternalRoom.g:10620:1: rule__ActorClass__Group__5 : rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6 ;
+    // InternalRoom.g:10849:1: rule__ActorClass__Group__5 : rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6 ;
     public final void rule__ActorClass__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10624:1: ( rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6 )
-            // InternalRoom.g:10625:2: rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6
+            // InternalRoom.g:10853:1: ( rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6 )
+            // InternalRoom.g:10854:2: rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__5__Impl();
@@ -30387,17 +31046,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__5__Impl"
-    // InternalRoom.g:10632:1: rule__ActorClass__Group__5__Impl : ( '{' ) ;
+    // InternalRoom.g:10861:1: rule__ActorClass__Group__5__Impl : ( '{' ) ;
     public final void rule__ActorClass__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10636:1: ( ( '{' ) )
-            // InternalRoom.g:10637:1: ( '{' )
+            // InternalRoom.g:10865:1: ( ( '{' ) )
+            // InternalRoom.g:10866:1: ( '{' )
             {
-            // InternalRoom.g:10637:1: ( '{' )
-            // InternalRoom.g:10638:1: '{'
+            // InternalRoom.g:10866:1: ( '{' )
+            // InternalRoom.g:10867:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_5()); 
             match(input,44,FOLLOW_2); 
@@ -30424,14 +31083,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__6"
-    // InternalRoom.g:10651:1: rule__ActorClass__Group__6 : rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7 ;
+    // InternalRoom.g:10880:1: rule__ActorClass__Group__6 : rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7 ;
     public final void rule__ActorClass__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10655:1: ( rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7 )
-            // InternalRoom.g:10656:2: rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7
+            // InternalRoom.g:10884:1: ( rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7 )
+            // InternalRoom.g:10885:2: rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__6__Impl();
@@ -30462,33 +31121,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__6__Impl"
-    // InternalRoom.g:10663:1: rule__ActorClass__Group__6__Impl : ( ( rule__ActorClass__AnnotationsAssignment_6 )* ) ;
+    // InternalRoom.g:10892:1: rule__ActorClass__Group__6__Impl : ( ( rule__ActorClass__AnnotationsAssignment_6 )* ) ;
     public final void rule__ActorClass__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10667:1: ( ( ( rule__ActorClass__AnnotationsAssignment_6 )* ) )
-            // InternalRoom.g:10668:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:10896:1: ( ( ( rule__ActorClass__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:10897:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:10668:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:10669:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
+            // InternalRoom.g:10897:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:10898:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getActorClassAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:10670:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
-            loop113:
+            // InternalRoom.g:10899:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
+            loop116:
             do {
-                int alt113=2;
-                int LA113_0 = input.LA(1);
+                int alt116=2;
+                int LA116_0 = input.LA(1);
 
-                if ( (LA113_0==121) ) {
-                    alt113=1;
+                if ( (LA116_0==121) ) {
+                    alt116=1;
                 }
 
 
-                switch (alt113) {
+                switch (alt116) {
             	case 1 :
-            	    // InternalRoom.g:10670:2: rule__ActorClass__AnnotationsAssignment_6
+            	    // InternalRoom.g:10899:2: rule__ActorClass__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ActorClass__AnnotationsAssignment_6();
@@ -30500,7 +31159,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop113;
+            	    break loop116;
                 }
             } while (true);
 
@@ -30527,14 +31186,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__7"
-    // InternalRoom.g:10680:1: rule__ActorClass__Group__7 : rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8 ;
+    // InternalRoom.g:10909:1: rule__ActorClass__Group__7 : rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8 ;
     public final void rule__ActorClass__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10684:1: ( rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8 )
-            // InternalRoom.g:10685:2: rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8
+            // InternalRoom.g:10913:1: ( rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8 )
+            // InternalRoom.g:10914:2: rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__7__Impl();
@@ -30565,29 +31224,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__7__Impl"
-    // InternalRoom.g:10692:1: rule__ActorClass__Group__7__Impl : ( ( rule__ActorClass__Group_7__0 )? ) ;
+    // InternalRoom.g:10921:1: rule__ActorClass__Group__7__Impl : ( ( rule__ActorClass__Group_7__0 )? ) ;
     public final void rule__ActorClass__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10696:1: ( ( ( rule__ActorClass__Group_7__0 )? ) )
-            // InternalRoom.g:10697:1: ( ( rule__ActorClass__Group_7__0 )? )
+            // InternalRoom.g:10925:1: ( ( ( rule__ActorClass__Group_7__0 )? ) )
+            // InternalRoom.g:10926:1: ( ( rule__ActorClass__Group_7__0 )? )
             {
-            // InternalRoom.g:10697:1: ( ( rule__ActorClass__Group_7__0 )? )
-            // InternalRoom.g:10698:1: ( rule__ActorClass__Group_7__0 )?
+            // InternalRoom.g:10926:1: ( ( rule__ActorClass__Group_7__0 )? )
+            // InternalRoom.g:10927:1: ( rule__ActorClass__Group_7__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_7()); 
-            // InternalRoom.g:10699:1: ( rule__ActorClass__Group_7__0 )?
-            int alt114=2;
-            int LA114_0 = input.LA(1);
+            // InternalRoom.g:10928:1: ( rule__ActorClass__Group_7__0 )?
+            int alt117=2;
+            int LA117_0 = input.LA(1);
 
-            if ( (LA114_0==74) ) {
-                alt114=1;
+            if ( (LA117_0==74) ) {
+                alt117=1;
             }
-            switch (alt114) {
+            switch (alt117) {
                 case 1 :
-                    // InternalRoom.g:10699:2: rule__ActorClass__Group_7__0
+                    // InternalRoom.g:10928:2: rule__ActorClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_7__0();
@@ -30623,14 +31282,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__8"
-    // InternalRoom.g:10709:1: rule__ActorClass__Group__8 : rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9 ;
+    // InternalRoom.g:10938:1: rule__ActorClass__Group__8 : rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9 ;
     public final void rule__ActorClass__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10713:1: ( rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9 )
-            // InternalRoom.g:10714:2: rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9
+            // InternalRoom.g:10942:1: ( rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9 )
+            // InternalRoom.g:10943:2: rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__8__Impl();
@@ -30661,29 +31320,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__8__Impl"
-    // InternalRoom.g:10721:1: rule__ActorClass__Group__8__Impl : ( ( rule__ActorClass__Group_8__0 )? ) ;
+    // InternalRoom.g:10950:1: rule__ActorClass__Group__8__Impl : ( ( rule__ActorClass__Group_8__0 )? ) ;
     public final void rule__ActorClass__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10725:1: ( ( ( rule__ActorClass__Group_8__0 )? ) )
-            // InternalRoom.g:10726:1: ( ( rule__ActorClass__Group_8__0 )? )
+            // InternalRoom.g:10954:1: ( ( ( rule__ActorClass__Group_8__0 )? ) )
+            // InternalRoom.g:10955:1: ( ( rule__ActorClass__Group_8__0 )? )
             {
-            // InternalRoom.g:10726:1: ( ( rule__ActorClass__Group_8__0 )? )
-            // InternalRoom.g:10727:1: ( rule__ActorClass__Group_8__0 )?
+            // InternalRoom.g:10955:1: ( ( rule__ActorClass__Group_8__0 )? )
+            // InternalRoom.g:10956:1: ( rule__ActorClass__Group_8__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_8()); 
-            // InternalRoom.g:10728:1: ( rule__ActorClass__Group_8__0 )?
-            int alt115=2;
-            int LA115_0 = input.LA(1);
+            // InternalRoom.g:10957:1: ( rule__ActorClass__Group_8__0 )?
+            int alt118=2;
+            int LA118_0 = input.LA(1);
 
-            if ( (LA115_0==75) ) {
-                alt115=1;
+            if ( (LA118_0==75) ) {
+                alt118=1;
             }
-            switch (alt115) {
+            switch (alt118) {
                 case 1 :
-                    // InternalRoom.g:10728:2: rule__ActorClass__Group_8__0
+                    // InternalRoom.g:10957:2: rule__ActorClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8__0();
@@ -30719,14 +31378,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__9"
-    // InternalRoom.g:10738:1: rule__ActorClass__Group__9 : rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10 ;
+    // InternalRoom.g:10967:1: rule__ActorClass__Group__9 : rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10 ;
     public final void rule__ActorClass__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10742:1: ( rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10 )
-            // InternalRoom.g:10743:2: rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10
+            // InternalRoom.g:10971:1: ( rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10 )
+            // InternalRoom.g:10972:2: rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__9__Impl();
@@ -30757,29 +31416,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__9__Impl"
-    // InternalRoom.g:10750:1: rule__ActorClass__Group__9__Impl : ( ( rule__ActorClass__Group_9__0 )? ) ;
+    // InternalRoom.g:10979:1: rule__ActorClass__Group__9__Impl : ( ( rule__ActorClass__Group_9__0 )? ) ;
     public final void rule__ActorClass__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10754:1: ( ( ( rule__ActorClass__Group_9__0 )? ) )
-            // InternalRoom.g:10755:1: ( ( rule__ActorClass__Group_9__0 )? )
+            // InternalRoom.g:10983:1: ( ( ( rule__ActorClass__Group_9__0 )? ) )
+            // InternalRoom.g:10984:1: ( ( rule__ActorClass__Group_9__0 )? )
             {
-            // InternalRoom.g:10755:1: ( ( rule__ActorClass__Group_9__0 )? )
-            // InternalRoom.g:10756:1: ( rule__ActorClass__Group_9__0 )?
+            // InternalRoom.g:10984:1: ( ( rule__ActorClass__Group_9__0 )? )
+            // InternalRoom.g:10985:1: ( rule__ActorClass__Group_9__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_9()); 
-            // InternalRoom.g:10757:1: ( rule__ActorClass__Group_9__0 )?
-            int alt116=2;
-            int LA116_0 = input.LA(1);
+            // InternalRoom.g:10986:1: ( rule__ActorClass__Group_9__0 )?
+            int alt119=2;
+            int LA119_0 = input.LA(1);
 
-            if ( (LA116_0==76) ) {
-                alt116=1;
+            if ( (LA119_0==76) ) {
+                alt119=1;
             }
-            switch (alt116) {
+            switch (alt119) {
                 case 1 :
-                    // InternalRoom.g:10757:2: rule__ActorClass__Group_9__0
+                    // InternalRoom.g:10986:2: rule__ActorClass__Group_9__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_9__0();
@@ -30815,14 +31474,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__10"
-    // InternalRoom.g:10767:1: rule__ActorClass__Group__10 : rule__ActorClass__Group__10__Impl ;
+    // InternalRoom.g:10996:1: rule__ActorClass__Group__10 : rule__ActorClass__Group__10__Impl ;
     public final void rule__ActorClass__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10771:1: ( rule__ActorClass__Group__10__Impl )
-            // InternalRoom.g:10772:2: rule__ActorClass__Group__10__Impl
+            // InternalRoom.g:11000:1: ( rule__ActorClass__Group__10__Impl )
+            // InternalRoom.g:11001:2: rule__ActorClass__Group__10__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group__10__Impl();
@@ -30848,17 +31507,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__10__Impl"
-    // InternalRoom.g:10778:1: rule__ActorClass__Group__10__Impl : ( '}' ) ;
+    // InternalRoom.g:11007:1: rule__ActorClass__Group__10__Impl : ( '}' ) ;
     public final void rule__ActorClass__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10782:1: ( ( '}' ) )
-            // InternalRoom.g:10783:1: ( '}' )
+            // InternalRoom.g:11011:1: ( ( '}' ) )
+            // InternalRoom.g:11012:1: ( '}' )
             {
-            // InternalRoom.g:10783:1: ( '}' )
-            // InternalRoom.g:10784:1: '}'
+            // InternalRoom.g:11012:1: ( '}' )
+            // InternalRoom.g:11013:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_10()); 
             match(input,45,FOLLOW_2); 
@@ -30885,14 +31544,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_4__0"
-    // InternalRoom.g:10819:1: rule__ActorClass__Group_4__0 : rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1 ;
+    // InternalRoom.g:11048:1: rule__ActorClass__Group_4__0 : rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1 ;
     public final void rule__ActorClass__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10823:1: ( rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1 )
-            // InternalRoom.g:10824:2: rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1
+            // InternalRoom.g:11052:1: ( rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1 )
+            // InternalRoom.g:11053:2: rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1
             {
             pushFollow(FOLLOW_3);
             rule__ActorClass__Group_4__0__Impl();
@@ -30923,17 +31582,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_4__0__Impl"
-    // InternalRoom.g:10831:1: rule__ActorClass__Group_4__0__Impl : ( 'extends' ) ;
+    // InternalRoom.g:11060:1: rule__ActorClass__Group_4__0__Impl : ( 'extends' ) ;
     public final void rule__ActorClass__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10835:1: ( ( 'extends' ) )
-            // InternalRoom.g:10836:1: ( 'extends' )
+            // InternalRoom.g:11064:1: ( ( 'extends' ) )
+            // InternalRoom.g:11065:1: ( 'extends' )
             {
-            // InternalRoom.g:10836:1: ( 'extends' )
-            // InternalRoom.g:10837:1: 'extends'
+            // InternalRoom.g:11065:1: ( 'extends' )
+            // InternalRoom.g:11066:1: 'extends'
             {
              before(grammarAccess.getActorClassAccess().getExtendsKeyword_4_0()); 
             match(input,57,FOLLOW_2); 
@@ -30960,14 +31619,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_4__1"
-    // InternalRoom.g:10850:1: rule__ActorClass__Group_4__1 : rule__ActorClass__Group_4__1__Impl ;
+    // InternalRoom.g:11079:1: rule__ActorClass__Group_4__1 : rule__ActorClass__Group_4__1__Impl ;
     public final void rule__ActorClass__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10854:1: ( rule__ActorClass__Group_4__1__Impl )
-            // InternalRoom.g:10855:2: rule__ActorClass__Group_4__1__Impl
+            // InternalRoom.g:11083:1: ( rule__ActorClass__Group_4__1__Impl )
+            // InternalRoom.g:11084:2: rule__ActorClass__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_4__1__Impl();
@@ -30993,21 +31652,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_4__1__Impl"
-    // InternalRoom.g:10861:1: rule__ActorClass__Group_4__1__Impl : ( ( rule__ActorClass__BaseAssignment_4_1 ) ) ;
+    // InternalRoom.g:11090:1: rule__ActorClass__Group_4__1__Impl : ( ( rule__ActorClass__BaseAssignment_4_1 ) ) ;
     public final void rule__ActorClass__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10865:1: ( ( ( rule__ActorClass__BaseAssignment_4_1 ) ) )
-            // InternalRoom.g:10866:1: ( ( rule__ActorClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:11094:1: ( ( ( rule__ActorClass__BaseAssignment_4_1 ) ) )
+            // InternalRoom.g:11095:1: ( ( rule__ActorClass__BaseAssignment_4_1 ) )
             {
-            // InternalRoom.g:10866:1: ( ( rule__ActorClass__BaseAssignment_4_1 ) )
-            // InternalRoom.g:10867:1: ( rule__ActorClass__BaseAssignment_4_1 )
+            // InternalRoom.g:11095:1: ( ( rule__ActorClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:11096:1: ( rule__ActorClass__BaseAssignment_4_1 )
             {
              before(grammarAccess.getActorClassAccess().getBaseAssignment_4_1()); 
-            // InternalRoom.g:10868:1: ( rule__ActorClass__BaseAssignment_4_1 )
-            // InternalRoom.g:10868:2: rule__ActorClass__BaseAssignment_4_1
+            // InternalRoom.g:11097:1: ( rule__ActorClass__BaseAssignment_4_1 )
+            // InternalRoom.g:11097:2: rule__ActorClass__BaseAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__BaseAssignment_4_1();
@@ -31040,14 +31699,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__0"
-    // InternalRoom.g:10882:1: rule__ActorClass__Group_7__0 : rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1 ;
+    // InternalRoom.g:11111:1: rule__ActorClass__Group_7__0 : rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1 ;
     public final void rule__ActorClass__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10886:1: ( rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1 )
-            // InternalRoom.g:10887:2: rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1
+            // InternalRoom.g:11115:1: ( rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1 )
+            // InternalRoom.g:11116:2: rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1
             {
             pushFollow(FOLLOW_40);
             rule__ActorClass__Group_7__0__Impl();
@@ -31078,17 +31737,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__0__Impl"
-    // InternalRoom.g:10894:1: rule__ActorClass__Group_7__0__Impl : ( 'Interface' ) ;
+    // InternalRoom.g:11123:1: rule__ActorClass__Group_7__0__Impl : ( 'Interface' ) ;
     public final void rule__ActorClass__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10898:1: ( ( 'Interface' ) )
-            // InternalRoom.g:10899:1: ( 'Interface' )
+            // InternalRoom.g:11127:1: ( ( 'Interface' ) )
+            // InternalRoom.g:11128:1: ( 'Interface' )
             {
-            // InternalRoom.g:10899:1: ( 'Interface' )
-            // InternalRoom.g:10900:1: 'Interface'
+            // InternalRoom.g:11128:1: ( 'Interface' )
+            // InternalRoom.g:11129:1: 'Interface'
             {
              before(grammarAccess.getActorClassAccess().getInterfaceKeyword_7_0()); 
             match(input,74,FOLLOW_2); 
@@ -31115,14 +31774,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__1"
-    // InternalRoom.g:10913:1: rule__ActorClass__Group_7__1 : rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2 ;
+    // InternalRoom.g:11142:1: rule__ActorClass__Group_7__1 : rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2 ;
     public final void rule__ActorClass__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10917:1: ( rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2 )
-            // InternalRoom.g:10918:2: rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2
+            // InternalRoom.g:11146:1: ( rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2 )
+            // InternalRoom.g:11147:2: rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2
             {
             pushFollow(FOLLOW_54);
             rule__ActorClass__Group_7__1__Impl();
@@ -31153,17 +31812,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__1__Impl"
-    // InternalRoom.g:10925:1: rule__ActorClass__Group_7__1__Impl : ( '{' ) ;
+    // InternalRoom.g:11154:1: rule__ActorClass__Group_7__1__Impl : ( '{' ) ;
     public final void rule__ActorClass__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10929:1: ( ( '{' ) )
-            // InternalRoom.g:10930:1: ( '{' )
+            // InternalRoom.g:11158:1: ( ( '{' ) )
+            // InternalRoom.g:11159:1: ( '{' )
             {
-            // InternalRoom.g:10930:1: ( '{' )
-            // InternalRoom.g:10931:1: '{'
+            // InternalRoom.g:11159:1: ( '{' )
+            // InternalRoom.g:11160:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_7_1()); 
             match(input,44,FOLLOW_2); 
@@ -31190,14 +31849,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__2"
-    // InternalRoom.g:10944:1: rule__ActorClass__Group_7__2 : rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3 ;
+    // InternalRoom.g:11173:1: rule__ActorClass__Group_7__2 : rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3 ;
     public final void rule__ActorClass__Group_7__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10948:1: ( rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3 )
-            // InternalRoom.g:10949:2: rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3
+            // InternalRoom.g:11177:1: ( rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3 )
+            // InternalRoom.g:11178:2: rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3
             {
             pushFollow(FOLLOW_54);
             rule__ActorClass__Group_7__2__Impl();
@@ -31228,33 +31887,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__2__Impl"
-    // InternalRoom.g:10956:1: rule__ActorClass__Group_7__2__Impl : ( ( rule__ActorClass__Alternatives_7_2 )* ) ;
+    // InternalRoom.g:11185:1: rule__ActorClass__Group_7__2__Impl : ( ( rule__ActorClass__Alternatives_7_2 )* ) ;
     public final void rule__ActorClass__Group_7__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10960:1: ( ( ( rule__ActorClass__Alternatives_7_2 )* ) )
-            // InternalRoom.g:10961:1: ( ( rule__ActorClass__Alternatives_7_2 )* )
+            // InternalRoom.g:11189:1: ( ( ( rule__ActorClass__Alternatives_7_2 )* ) )
+            // InternalRoom.g:11190:1: ( ( rule__ActorClass__Alternatives_7_2 )* )
             {
-            // InternalRoom.g:10961:1: ( ( rule__ActorClass__Alternatives_7_2 )* )
-            // InternalRoom.g:10962:1: ( rule__ActorClass__Alternatives_7_2 )*
+            // InternalRoom.g:11190:1: ( ( rule__ActorClass__Alternatives_7_2 )* )
+            // InternalRoom.g:11191:1: ( rule__ActorClass__Alternatives_7_2 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_7_2()); 
-            // InternalRoom.g:10963:1: ( rule__ActorClass__Alternatives_7_2 )*
-            loop117:
+            // InternalRoom.g:11192:1: ( rule__ActorClass__Alternatives_7_2 )*
+            loop120:
             do {
-                int alt117=2;
-                int LA117_0 = input.LA(1);
+                int alt120=2;
+                int LA120_0 = input.LA(1);
 
-                if ( (LA117_0==24||LA117_0==70||LA117_0==79) ) {
-                    alt117=1;
+                if ( (LA120_0==24||LA120_0==70||LA120_0==79) ) {
+                    alt120=1;
                 }
 
 
-                switch (alt117) {
+                switch (alt120) {
             	case 1 :
-            	    // InternalRoom.g:10963:2: rule__ActorClass__Alternatives_7_2
+            	    // InternalRoom.g:11192:2: rule__ActorClass__Alternatives_7_2
             	    {
             	    pushFollow(FOLLOW_55);
             	    rule__ActorClass__Alternatives_7_2();
@@ -31266,7 +31925,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop117;
+            	    break loop120;
                 }
             } while (true);
 
@@ -31293,14 +31952,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__3"
-    // InternalRoom.g:10973:1: rule__ActorClass__Group_7__3 : rule__ActorClass__Group_7__3__Impl ;
+    // InternalRoom.g:11202:1: rule__ActorClass__Group_7__3 : rule__ActorClass__Group_7__3__Impl ;
     public final void rule__ActorClass__Group_7__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10977:1: ( rule__ActorClass__Group_7__3__Impl )
-            // InternalRoom.g:10978:2: rule__ActorClass__Group_7__3__Impl
+            // InternalRoom.g:11206:1: ( rule__ActorClass__Group_7__3__Impl )
+            // InternalRoom.g:11207:2: rule__ActorClass__Group_7__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_7__3__Impl();
@@ -31326,17 +31985,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_7__3__Impl"
-    // InternalRoom.g:10984:1: rule__ActorClass__Group_7__3__Impl : ( '}' ) ;
+    // InternalRoom.g:11213:1: rule__ActorClass__Group_7__3__Impl : ( '}' ) ;
     public final void rule__ActorClass__Group_7__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:10988:1: ( ( '}' ) )
-            // InternalRoom.g:10989:1: ( '}' )
+            // InternalRoom.g:11217:1: ( ( '}' ) )
+            // InternalRoom.g:11218:1: ( '}' )
             {
-            // InternalRoom.g:10989:1: ( '}' )
-            // InternalRoom.g:10990:1: '}'
+            // InternalRoom.g:11218:1: ( '}' )
+            // InternalRoom.g:11219:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_7_3()); 
             match(input,45,FOLLOW_2); 
@@ -31363,14 +32022,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__0"
-    // InternalRoom.g:11011:1: rule__ActorClass__Group_8__0 : rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1 ;
+    // InternalRoom.g:11240:1: rule__ActorClass__Group_8__0 : rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1 ;
     public final void rule__ActorClass__Group_8__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11015:1: ( rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1 )
-            // InternalRoom.g:11016:2: rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1
+            // InternalRoom.g:11244:1: ( rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1 )
+            // InternalRoom.g:11245:2: rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_8__0__Impl();
@@ -31401,17 +32060,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__0__Impl"
-    // InternalRoom.g:11023:1: rule__ActorClass__Group_8__0__Impl : ( 'Structure' ) ;
+    // InternalRoom.g:11252:1: rule__ActorClass__Group_8__0__Impl : ( 'Structure' ) ;
     public final void rule__ActorClass__Group_8__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11027:1: ( ( 'Structure' ) )
-            // InternalRoom.g:11028:1: ( 'Structure' )
+            // InternalRoom.g:11256:1: ( ( 'Structure' ) )
+            // InternalRoom.g:11257:1: ( 'Structure' )
             {
-            // InternalRoom.g:11028:1: ( 'Structure' )
-            // InternalRoom.g:11029:1: 'Structure'
+            // InternalRoom.g:11257:1: ( 'Structure' )
+            // InternalRoom.g:11258:1: 'Structure'
             {
              before(grammarAccess.getActorClassAccess().getStructureKeyword_8_0()); 
             match(input,75,FOLLOW_2); 
@@ -31438,14 +32097,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__1"
-    // InternalRoom.g:11042:1: rule__ActorClass__Group_8__1 : rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2 ;
+    // InternalRoom.g:11271:1: rule__ActorClass__Group_8__1 : rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2 ;
     public final void rule__ActorClass__Group_8__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11046:1: ( rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2 )
-            // InternalRoom.g:11047:2: rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2
+            // InternalRoom.g:11275:1: ( rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2 )
+            // InternalRoom.g:11276:2: rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_8__1__Impl();
@@ -31476,29 +32135,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__1__Impl"
-    // InternalRoom.g:11054:1: rule__ActorClass__Group_8__1__Impl : ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? ) ;
+    // InternalRoom.g:11283:1: rule__ActorClass__Group_8__1__Impl : ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? ) ;
     public final void rule__ActorClass__Group_8__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11058:1: ( ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? ) )
-            // InternalRoom.g:11059:1: ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? )
+            // InternalRoom.g:11287:1: ( ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? ) )
+            // InternalRoom.g:11288:1: ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? )
             {
-            // InternalRoom.g:11059:1: ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? )
-            // InternalRoom.g:11060:1: ( rule__ActorClass__StructureDocuAssignment_8_1 )?
+            // InternalRoom.g:11288:1: ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? )
+            // InternalRoom.g:11289:1: ( rule__ActorClass__StructureDocuAssignment_8_1 )?
             {
              before(grammarAccess.getActorClassAccess().getStructureDocuAssignment_8_1()); 
-            // InternalRoom.g:11061:1: ( rule__ActorClass__StructureDocuAssignment_8_1 )?
-            int alt118=2;
-            int LA118_0 = input.LA(1);
+            // InternalRoom.g:11290:1: ( rule__ActorClass__StructureDocuAssignment_8_1 )?
+            int alt121=2;
+            int LA121_0 = input.LA(1);
 
-            if ( (LA118_0==62) ) {
-                alt118=1;
+            if ( (LA121_0==62) ) {
+                alt121=1;
             }
-            switch (alt118) {
+            switch (alt121) {
                 case 1 :
-                    // InternalRoom.g:11061:2: rule__ActorClass__StructureDocuAssignment_8_1
+                    // InternalRoom.g:11290:2: rule__ActorClass__StructureDocuAssignment_8_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StructureDocuAssignment_8_1();
@@ -31534,14 +32193,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__2"
-    // InternalRoom.g:11071:1: rule__ActorClass__Group_8__2 : rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3 ;
+    // InternalRoom.g:11300:1: rule__ActorClass__Group_8__2 : rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3 ;
     public final void rule__ActorClass__Group_8__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11075:1: ( rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3 )
-            // InternalRoom.g:11076:2: rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3
+            // InternalRoom.g:11304:1: ( rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3 )
+            // InternalRoom.g:11305:2: rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__2__Impl();
@@ -31572,17 +32231,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__2__Impl"
-    // InternalRoom.g:11083:1: rule__ActorClass__Group_8__2__Impl : ( '{' ) ;
+    // InternalRoom.g:11312:1: rule__ActorClass__Group_8__2__Impl : ( '{' ) ;
     public final void rule__ActorClass__Group_8__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11087:1: ( ( '{' ) )
-            // InternalRoom.g:11088:1: ( '{' )
+            // InternalRoom.g:11316:1: ( ( '{' ) )
+            // InternalRoom.g:11317:1: ( '{' )
             {
-            // InternalRoom.g:11088:1: ( '{' )
-            // InternalRoom.g:11089:1: '{'
+            // InternalRoom.g:11317:1: ( '{' )
+            // InternalRoom.g:11318:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_8_2()); 
             match(input,44,FOLLOW_2); 
@@ -31609,14 +32268,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__3"
-    // InternalRoom.g:11102:1: rule__ActorClass__Group_8__3 : rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4 ;
+    // InternalRoom.g:11331:1: rule__ActorClass__Group_8__3 : rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4 ;
     public final void rule__ActorClass__Group_8__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11106:1: ( rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4 )
-            // InternalRoom.g:11107:2: rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4
+            // InternalRoom.g:11335:1: ( rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4 )
+            // InternalRoom.g:11336:2: rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__3__Impl();
@@ -31647,29 +32306,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__3__Impl"
-    // InternalRoom.g:11114:1: rule__ActorClass__Group_8__3__Impl : ( ( rule__ActorClass__Group_8_3__0 )? ) ;
+    // InternalRoom.g:11343:1: rule__ActorClass__Group_8__3__Impl : ( ( rule__ActorClass__Group_8_3__0 )? ) ;
     public final void rule__ActorClass__Group_8__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11118:1: ( ( ( rule__ActorClass__Group_8_3__0 )? ) )
-            // InternalRoom.g:11119:1: ( ( rule__ActorClass__Group_8_3__0 )? )
+            // InternalRoom.g:11347:1: ( ( ( rule__ActorClass__Group_8_3__0 )? ) )
+            // InternalRoom.g:11348:1: ( ( rule__ActorClass__Group_8_3__0 )? )
             {
-            // InternalRoom.g:11119:1: ( ( rule__ActorClass__Group_8_3__0 )? )
-            // InternalRoom.g:11120:1: ( rule__ActorClass__Group_8_3__0 )?
+            // InternalRoom.g:11348:1: ( ( rule__ActorClass__Group_8_3__0 )? )
+            // InternalRoom.g:11349:1: ( rule__ActorClass__Group_8_3__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_8_3()); 
-            // InternalRoom.g:11121:1: ( rule__ActorClass__Group_8_3__0 )?
-            int alt119=2;
-            int LA119_0 = input.LA(1);
+            // InternalRoom.g:11350:1: ( rule__ActorClass__Group_8_3__0 )?
+            int alt122=2;
+            int LA122_0 = input.LA(1);
 
-            if ( (LA119_0==58) ) {
-                alt119=1;
+            if ( (LA122_0==58) ) {
+                alt122=1;
             }
-            switch (alt119) {
+            switch (alt122) {
                 case 1 :
-                    // InternalRoom.g:11121:2: rule__ActorClass__Group_8_3__0
+                    // InternalRoom.g:11350:2: rule__ActorClass__Group_8_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_3__0();
@@ -31705,14 +32364,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__4"
-    // InternalRoom.g:11131:1: rule__ActorClass__Group_8__4 : rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5 ;
+    // InternalRoom.g:11360:1: rule__ActorClass__Group_8__4 : rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5 ;
     public final void rule__ActorClass__Group_8__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11135:1: ( rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5 )
-            // InternalRoom.g:11136:2: rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5
+            // InternalRoom.g:11364:1: ( rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5 )
+            // InternalRoom.g:11365:2: rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__4__Impl();
@@ -31743,29 +32402,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__4__Impl"
-    // InternalRoom.g:11143:1: rule__ActorClass__Group_8__4__Impl : ( ( rule__ActorClass__Group_8_4__0 )? ) ;
+    // InternalRoom.g:11372:1: rule__ActorClass__Group_8__4__Impl : ( ( rule__ActorClass__Group_8_4__0 )? ) ;
     public final void rule__ActorClass__Group_8__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11147:1: ( ( ( rule__ActorClass__Group_8_4__0 )? ) )
-            // InternalRoom.g:11148:1: ( ( rule__ActorClass__Group_8_4__0 )? )
+            // InternalRoom.g:11376:1: ( ( ( rule__ActorClass__Group_8_4__0 )? ) )
+            // InternalRoom.g:11377:1: ( ( rule__ActorClass__Group_8_4__0 )? )
             {
-            // InternalRoom.g:11148:1: ( ( rule__ActorClass__Group_8_4__0 )? )
-            // InternalRoom.g:11149:1: ( rule__ActorClass__Group_8_4__0 )?
+            // InternalRoom.g:11377:1: ( ( rule__ActorClass__Group_8_4__0 )? )
+            // InternalRoom.g:11378:1: ( rule__ActorClass__Group_8_4__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_8_4()); 
-            // InternalRoom.g:11150:1: ( rule__ActorClass__Group_8_4__0 )?
-            int alt120=2;
-            int LA120_0 = input.LA(1);
+            // InternalRoom.g:11379:1: ( rule__ActorClass__Group_8_4__0 )?
+            int alt123=2;
+            int LA123_0 = input.LA(1);
 
-            if ( (LA120_0==59) ) {
-                alt120=1;
+            if ( (LA123_0==59) ) {
+                alt123=1;
             }
-            switch (alt120) {
+            switch (alt123) {
                 case 1 :
-                    // InternalRoom.g:11150:2: rule__ActorClass__Group_8_4__0
+                    // InternalRoom.g:11379:2: rule__ActorClass__Group_8_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_4__0();
@@ -31801,14 +32460,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__5"
-    // InternalRoom.g:11160:1: rule__ActorClass__Group_8__5 : rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6 ;
+    // InternalRoom.g:11389:1: rule__ActorClass__Group_8__5 : rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6 ;
     public final void rule__ActorClass__Group_8__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11164:1: ( rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6 )
-            // InternalRoom.g:11165:2: rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6
+            // InternalRoom.g:11393:1: ( rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6 )
+            // InternalRoom.g:11394:2: rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__5__Impl();
@@ -31839,29 +32498,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__5__Impl"
-    // InternalRoom.g:11172:1: rule__ActorClass__Group_8__5__Impl : ( ( rule__ActorClass__Group_8_5__0 )? ) ;
+    // InternalRoom.g:11401:1: rule__ActorClass__Group_8__5__Impl : ( ( rule__ActorClass__Group_8_5__0 )? ) ;
     public final void rule__ActorClass__Group_8__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11176:1: ( ( ( rule__ActorClass__Group_8_5__0 )? ) )
-            // InternalRoom.g:11177:1: ( ( rule__ActorClass__Group_8_5__0 )? )
+            // InternalRoom.g:11405:1: ( ( ( rule__ActorClass__Group_8_5__0 )? ) )
+            // InternalRoom.g:11406:1: ( ( rule__ActorClass__Group_8_5__0 )? )
             {
-            // InternalRoom.g:11177:1: ( ( rule__ActorClass__Group_8_5__0 )? )
-            // InternalRoom.g:11178:1: ( rule__ActorClass__Group_8_5__0 )?
+            // InternalRoom.g:11406:1: ( ( rule__ActorClass__Group_8_5__0 )? )
+            // InternalRoom.g:11407:1: ( rule__ActorClass__Group_8_5__0 )?
             {
              before(grammarAccess.getActorClassAccess().getGroup_8_5()); 
-            // InternalRoom.g:11179:1: ( rule__ActorClass__Group_8_5__0 )?
-            int alt121=2;
-            int LA121_0 = input.LA(1);
+            // InternalRoom.g:11408:1: ( rule__ActorClass__Group_8_5__0 )?
+            int alt124=2;
+            int LA124_0 = input.LA(1);
 
-            if ( (LA121_0==60) ) {
-                alt121=1;
+            if ( (LA124_0==60) ) {
+                alt124=1;
             }
-            switch (alt121) {
+            switch (alt124) {
                 case 1 :
-                    // InternalRoom.g:11179:2: rule__ActorClass__Group_8_5__0
+                    // InternalRoom.g:11408:2: rule__ActorClass__Group_8_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_5__0();
@@ -31897,14 +32556,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__6"
-    // InternalRoom.g:11189:1: rule__ActorClass__Group_8__6 : rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7 ;
+    // InternalRoom.g:11418:1: rule__ActorClass__Group_8__6 : rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7 ;
     public final void rule__ActorClass__Group_8__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11193:1: ( rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7 )
-            // InternalRoom.g:11194:2: rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7
+            // InternalRoom.g:11422:1: ( rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7 )
+            // InternalRoom.g:11423:2: rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__6__Impl();
@@ -31935,33 +32594,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__6__Impl"
-    // InternalRoom.g:11201:1: rule__ActorClass__Group_8__6__Impl : ( ( rule__ActorClass__Alternatives_8_6 )* ) ;
+    // InternalRoom.g:11430:1: rule__ActorClass__Group_8__6__Impl : ( ( rule__ActorClass__Alternatives_8_6 )* ) ;
     public final void rule__ActorClass__Group_8__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11205:1: ( ( ( rule__ActorClass__Alternatives_8_6 )* ) )
-            // InternalRoom.g:11206:1: ( ( rule__ActorClass__Alternatives_8_6 )* )
+            // InternalRoom.g:11434:1: ( ( ( rule__ActorClass__Alternatives_8_6 )* ) )
+            // InternalRoom.g:11435:1: ( ( rule__ActorClass__Alternatives_8_6 )* )
             {
-            // InternalRoom.g:11206:1: ( ( rule__ActorClass__Alternatives_8_6 )* )
-            // InternalRoom.g:11207:1: ( rule__ActorClass__Alternatives_8_6 )*
+            // InternalRoom.g:11435:1: ( ( rule__ActorClass__Alternatives_8_6 )* )
+            // InternalRoom.g:11436:1: ( rule__ActorClass__Alternatives_8_6 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_8_6()); 
-            // InternalRoom.g:11208:1: ( rule__ActorClass__Alternatives_8_6 )*
-            loop122:
+            // InternalRoom.g:11437:1: ( rule__ActorClass__Alternatives_8_6 )*
+            loop125:
             do {
-                int alt122=2;
-                int LA122_0 = input.LA(1);
+                int alt125=2;
+                int LA125_0 = input.LA(1);
 
-                if ( (LA122_0==24||(LA122_0>=36 && LA122_0<=37)||LA122_0==61||LA122_0==70||(LA122_0>=77 && LA122_0<=78)||LA122_0==80||LA122_0==85||LA122_0==89||LA122_0==93) ) {
-                    alt122=1;
+                if ( (LA125_0==24||(LA125_0>=36 && LA125_0<=37)||LA125_0==61||LA125_0==70||(LA125_0>=77 && LA125_0<=78)||LA125_0==80||LA125_0==85||LA125_0==89||LA125_0==93) ) {
+                    alt125=1;
                 }
 
 
-                switch (alt122) {
+                switch (alt125) {
             	case 1 :
-            	    // InternalRoom.g:11208:2: rule__ActorClass__Alternatives_8_6
+            	    // InternalRoom.g:11437:2: rule__ActorClass__Alternatives_8_6
             	    {
             	    pushFollow(FOLLOW_57);
             	    rule__ActorClass__Alternatives_8_6();
@@ -31973,7 +32632,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop122;
+            	    break loop125;
                 }
             } while (true);
 
@@ -32000,14 +32659,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__7"
-    // InternalRoom.g:11218:1: rule__ActorClass__Group_8__7 : rule__ActorClass__Group_8__7__Impl ;
+    // InternalRoom.g:11447:1: rule__ActorClass__Group_8__7 : rule__ActorClass__Group_8__7__Impl ;
     public final void rule__ActorClass__Group_8__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11222:1: ( rule__ActorClass__Group_8__7__Impl )
-            // InternalRoom.g:11223:2: rule__ActorClass__Group_8__7__Impl
+            // InternalRoom.g:11451:1: ( rule__ActorClass__Group_8__7__Impl )
+            // InternalRoom.g:11452:2: rule__ActorClass__Group_8__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8__7__Impl();
@@ -32033,17 +32692,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8__7__Impl"
-    // InternalRoom.g:11229:1: rule__ActorClass__Group_8__7__Impl : ( '}' ) ;
+    // InternalRoom.g:11458:1: rule__ActorClass__Group_8__7__Impl : ( '}' ) ;
     public final void rule__ActorClass__Group_8__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11233:1: ( ( '}' ) )
-            // InternalRoom.g:11234:1: ( '}' )
+            // InternalRoom.g:11462:1: ( ( '}' ) )
+            // InternalRoom.g:11463:1: ( '}' )
             {
-            // InternalRoom.g:11234:1: ( '}' )
-            // InternalRoom.g:11235:1: '}'
+            // InternalRoom.g:11463:1: ( '}' )
+            // InternalRoom.g:11464:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_8_7()); 
             match(input,45,FOLLOW_2); 
@@ -32070,14 +32729,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_3__0"
-    // InternalRoom.g:11264:1: rule__ActorClass__Group_8_3__0 : rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1 ;
+    // InternalRoom.g:11493:1: rule__ActorClass__Group_8_3__0 : rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1 ;
     public final void rule__ActorClass__Group_8_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11268:1: ( rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1 )
-            // InternalRoom.g:11269:2: rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1
+            // InternalRoom.g:11497:1: ( rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1 )
+            // InternalRoom.g:11498:2: rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1
             {
             pushFollow(FOLLOW_27);
             rule__ActorClass__Group_8_3__0__Impl();
@@ -32108,17 +32767,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_3__0__Impl"
-    // InternalRoom.g:11276:1: rule__ActorClass__Group_8_3__0__Impl : ( 'usercode1' ) ;
+    // InternalRoom.g:11505:1: rule__ActorClass__Group_8_3__0__Impl : ( 'usercode1' ) ;
     public final void rule__ActorClass__Group_8_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11280:1: ( ( 'usercode1' ) )
-            // InternalRoom.g:11281:1: ( 'usercode1' )
+            // InternalRoom.g:11509:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:11510:1: ( 'usercode1' )
             {
-            // InternalRoom.g:11281:1: ( 'usercode1' )
-            // InternalRoom.g:11282:1: 'usercode1'
+            // InternalRoom.g:11510:1: ( 'usercode1' )
+            // InternalRoom.g:11511:1: 'usercode1'
             {
              before(grammarAccess.getActorClassAccess().getUsercode1Keyword_8_3_0()); 
             match(input,58,FOLLOW_2); 
@@ -32145,14 +32804,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_3__1"
-    // InternalRoom.g:11295:1: rule__ActorClass__Group_8_3__1 : rule__ActorClass__Group_8_3__1__Impl ;
+    // InternalRoom.g:11524:1: rule__ActorClass__Group_8_3__1 : rule__ActorClass__Group_8_3__1__Impl ;
     public final void rule__ActorClass__Group_8_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11299:1: ( rule__ActorClass__Group_8_3__1__Impl )
-            // InternalRoom.g:11300:2: rule__ActorClass__Group_8_3__1__Impl
+            // InternalRoom.g:11528:1: ( rule__ActorClass__Group_8_3__1__Impl )
+            // InternalRoom.g:11529:2: rule__ActorClass__Group_8_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_3__1__Impl();
@@ -32178,21 +32837,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_3__1__Impl"
-    // InternalRoom.g:11306:1: rule__ActorClass__Group_8_3__1__Impl : ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) ) ;
+    // InternalRoom.g:11535:1: rule__ActorClass__Group_8_3__1__Impl : ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) ) ;
     public final void rule__ActorClass__Group_8_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11310:1: ( ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) ) )
-            // InternalRoom.g:11311:1: ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) )
+            // InternalRoom.g:11539:1: ( ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) ) )
+            // InternalRoom.g:11540:1: ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) )
             {
-            // InternalRoom.g:11311:1: ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) )
-            // InternalRoom.g:11312:1: ( rule__ActorClass__UserCode1Assignment_8_3_1 )
+            // InternalRoom.g:11540:1: ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) )
+            // InternalRoom.g:11541:1: ( rule__ActorClass__UserCode1Assignment_8_3_1 )
             {
              before(grammarAccess.getActorClassAccess().getUserCode1Assignment_8_3_1()); 
-            // InternalRoom.g:11313:1: ( rule__ActorClass__UserCode1Assignment_8_3_1 )
-            // InternalRoom.g:11313:2: rule__ActorClass__UserCode1Assignment_8_3_1
+            // InternalRoom.g:11542:1: ( rule__ActorClass__UserCode1Assignment_8_3_1 )
+            // InternalRoom.g:11542:2: rule__ActorClass__UserCode1Assignment_8_3_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode1Assignment_8_3_1();
@@ -32225,14 +32884,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_4__0"
-    // InternalRoom.g:11327:1: rule__ActorClass__Group_8_4__0 : rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1 ;
+    // InternalRoom.g:11556:1: rule__ActorClass__Group_8_4__0 : rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1 ;
     public final void rule__ActorClass__Group_8_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11331:1: ( rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1 )
-            // InternalRoom.g:11332:2: rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1
+            // InternalRoom.g:11560:1: ( rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1 )
+            // InternalRoom.g:11561:2: rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1
             {
             pushFollow(FOLLOW_27);
             rule__ActorClass__Group_8_4__0__Impl();
@@ -32263,17 +32922,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_4__0__Impl"
-    // InternalRoom.g:11339:1: rule__ActorClass__Group_8_4__0__Impl : ( 'usercode2' ) ;
+    // InternalRoom.g:11568:1: rule__ActorClass__Group_8_4__0__Impl : ( 'usercode2' ) ;
     public final void rule__ActorClass__Group_8_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11343:1: ( ( 'usercode2' ) )
-            // InternalRoom.g:11344:1: ( 'usercode2' )
+            // InternalRoom.g:11572:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:11573:1: ( 'usercode2' )
             {
-            // InternalRoom.g:11344:1: ( 'usercode2' )
-            // InternalRoom.g:11345:1: 'usercode2'
+            // InternalRoom.g:11573:1: ( 'usercode2' )
+            // InternalRoom.g:11574:1: 'usercode2'
             {
              before(grammarAccess.getActorClassAccess().getUsercode2Keyword_8_4_0()); 
             match(input,59,FOLLOW_2); 
@@ -32300,14 +32959,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_4__1"
-    // InternalRoom.g:11358:1: rule__ActorClass__Group_8_4__1 : rule__ActorClass__Group_8_4__1__Impl ;
+    // InternalRoom.g:11587:1: rule__ActorClass__Group_8_4__1 : rule__ActorClass__Group_8_4__1__Impl ;
     public final void rule__ActorClass__Group_8_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11362:1: ( rule__ActorClass__Group_8_4__1__Impl )
-            // InternalRoom.g:11363:2: rule__ActorClass__Group_8_4__1__Impl
+            // InternalRoom.g:11591:1: ( rule__ActorClass__Group_8_4__1__Impl )
+            // InternalRoom.g:11592:2: rule__ActorClass__Group_8_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_4__1__Impl();
@@ -32333,21 +32992,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_4__1__Impl"
-    // InternalRoom.g:11369:1: rule__ActorClass__Group_8_4__1__Impl : ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) ) ;
+    // InternalRoom.g:11598:1: rule__ActorClass__Group_8_4__1__Impl : ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) ) ;
     public final void rule__ActorClass__Group_8_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11373:1: ( ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) ) )
-            // InternalRoom.g:11374:1: ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) )
+            // InternalRoom.g:11602:1: ( ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) ) )
+            // InternalRoom.g:11603:1: ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) )
             {
-            // InternalRoom.g:11374:1: ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) )
-            // InternalRoom.g:11375:1: ( rule__ActorClass__UserCode2Assignment_8_4_1 )
+            // InternalRoom.g:11603:1: ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) )
+            // InternalRoom.g:11604:1: ( rule__ActorClass__UserCode2Assignment_8_4_1 )
             {
              before(grammarAccess.getActorClassAccess().getUserCode2Assignment_8_4_1()); 
-            // InternalRoom.g:11376:1: ( rule__ActorClass__UserCode2Assignment_8_4_1 )
-            // InternalRoom.g:11376:2: rule__ActorClass__UserCode2Assignment_8_4_1
+            // InternalRoom.g:11605:1: ( rule__ActorClass__UserCode2Assignment_8_4_1 )
+            // InternalRoom.g:11605:2: rule__ActorClass__UserCode2Assignment_8_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode2Assignment_8_4_1();
@@ -32380,14 +33039,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_5__0"
-    // InternalRoom.g:11390:1: rule__ActorClass__Group_8_5__0 : rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1 ;
+    // InternalRoom.g:11619:1: rule__ActorClass__Group_8_5__0 : rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1 ;
     public final void rule__ActorClass__Group_8_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11394:1: ( rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1 )
-            // InternalRoom.g:11395:2: rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1
+            // InternalRoom.g:11623:1: ( rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1 )
+            // InternalRoom.g:11624:2: rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1
             {
             pushFollow(FOLLOW_27);
             rule__ActorClass__Group_8_5__0__Impl();
@@ -32418,17 +33077,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_5__0__Impl"
-    // InternalRoom.g:11402:1: rule__ActorClass__Group_8_5__0__Impl : ( 'usercode3' ) ;
+    // InternalRoom.g:11631:1: rule__ActorClass__Group_8_5__0__Impl : ( 'usercode3' ) ;
     public final void rule__ActorClass__Group_8_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11406:1: ( ( 'usercode3' ) )
-            // InternalRoom.g:11407:1: ( 'usercode3' )
+            // InternalRoom.g:11635:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:11636:1: ( 'usercode3' )
             {
-            // InternalRoom.g:11407:1: ( 'usercode3' )
-            // InternalRoom.g:11408:1: 'usercode3'
+            // InternalRoom.g:11636:1: ( 'usercode3' )
+            // InternalRoom.g:11637:1: 'usercode3'
             {
              before(grammarAccess.getActorClassAccess().getUsercode3Keyword_8_5_0()); 
             match(input,60,FOLLOW_2); 
@@ -32455,14 +33114,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_5__1"
-    // InternalRoom.g:11421:1: rule__ActorClass__Group_8_5__1 : rule__ActorClass__Group_8_5__1__Impl ;
+    // InternalRoom.g:11650:1: rule__ActorClass__Group_8_5__1 : rule__ActorClass__Group_8_5__1__Impl ;
     public final void rule__ActorClass__Group_8_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11425:1: ( rule__ActorClass__Group_8_5__1__Impl )
-            // InternalRoom.g:11426:2: rule__ActorClass__Group_8_5__1__Impl
+            // InternalRoom.g:11654:1: ( rule__ActorClass__Group_8_5__1__Impl )
+            // InternalRoom.g:11655:2: rule__ActorClass__Group_8_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_5__1__Impl();
@@ -32488,21 +33147,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_8_5__1__Impl"
-    // InternalRoom.g:11432:1: rule__ActorClass__Group_8_5__1__Impl : ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) ) ;
+    // InternalRoom.g:11661:1: rule__ActorClass__Group_8_5__1__Impl : ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) ) ;
     public final void rule__ActorClass__Group_8_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11436:1: ( ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) ) )
-            // InternalRoom.g:11437:1: ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) )
+            // InternalRoom.g:11665:1: ( ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) ) )
+            // InternalRoom.g:11666:1: ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) )
             {
-            // InternalRoom.g:11437:1: ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) )
-            // InternalRoom.g:11438:1: ( rule__ActorClass__UserCode3Assignment_8_5_1 )
+            // InternalRoom.g:11666:1: ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) )
+            // InternalRoom.g:11667:1: ( rule__ActorClass__UserCode3Assignment_8_5_1 )
             {
              before(grammarAccess.getActorClassAccess().getUserCode3Assignment_8_5_1()); 
-            // InternalRoom.g:11439:1: ( rule__ActorClass__UserCode3Assignment_8_5_1 )
-            // InternalRoom.g:11439:2: rule__ActorClass__UserCode3Assignment_8_5_1
+            // InternalRoom.g:11668:1: ( rule__ActorClass__UserCode3Assignment_8_5_1 )
+            // InternalRoom.g:11668:2: rule__ActorClass__UserCode3Assignment_8_5_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode3Assignment_8_5_1();
@@ -32535,14 +33194,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__0"
-    // InternalRoom.g:11453:1: rule__ActorClass__Group_9__0 : rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1 ;
+    // InternalRoom.g:11682:1: rule__ActorClass__Group_9__0 : rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1 ;
     public final void rule__ActorClass__Group_9__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11457:1: ( rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1 )
-            // InternalRoom.g:11458:2: rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1
+            // InternalRoom.g:11686:1: ( rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1 )
+            // InternalRoom.g:11687:2: rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_9__0__Impl();
@@ -32573,17 +33232,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__0__Impl"
-    // InternalRoom.g:11465:1: rule__ActorClass__Group_9__0__Impl : ( 'Behavior' ) ;
+    // InternalRoom.g:11694:1: rule__ActorClass__Group_9__0__Impl : ( 'Behavior' ) ;
     public final void rule__ActorClass__Group_9__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11469:1: ( ( 'Behavior' ) )
-            // InternalRoom.g:11470:1: ( 'Behavior' )
+            // InternalRoom.g:11698:1: ( ( 'Behavior' ) )
+            // InternalRoom.g:11699:1: ( 'Behavior' )
             {
-            // InternalRoom.g:11470:1: ( 'Behavior' )
-            // InternalRoom.g:11471:1: 'Behavior'
+            // InternalRoom.g:11699:1: ( 'Behavior' )
+            // InternalRoom.g:11700:1: 'Behavior'
             {
              before(grammarAccess.getActorClassAccess().getBehaviorKeyword_9_0()); 
             match(input,76,FOLLOW_2); 
@@ -32610,14 +33269,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__1"
-    // InternalRoom.g:11484:1: rule__ActorClass__Group_9__1 : rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2 ;
+    // InternalRoom.g:11713:1: rule__ActorClass__Group_9__1 : rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2 ;
     public final void rule__ActorClass__Group_9__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11488:1: ( rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2 )
-            // InternalRoom.g:11489:2: rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2
+            // InternalRoom.g:11717:1: ( rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2 )
+            // InternalRoom.g:11718:2: rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_9__1__Impl();
@@ -32648,29 +33307,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__1__Impl"
-    // InternalRoom.g:11496:1: rule__ActorClass__Group_9__1__Impl : ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? ) ;
+    // InternalRoom.g:11725:1: rule__ActorClass__Group_9__1__Impl : ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? ) ;
     public final void rule__ActorClass__Group_9__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11500:1: ( ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? ) )
-            // InternalRoom.g:11501:1: ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? )
+            // InternalRoom.g:11729:1: ( ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? ) )
+            // InternalRoom.g:11730:1: ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? )
             {
-            // InternalRoom.g:11501:1: ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? )
-            // InternalRoom.g:11502:1: ( rule__ActorClass__BehaviorDocuAssignment_9_1 )?
+            // InternalRoom.g:11730:1: ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? )
+            // InternalRoom.g:11731:1: ( rule__ActorClass__BehaviorDocuAssignment_9_1 )?
             {
              before(grammarAccess.getActorClassAccess().getBehaviorDocuAssignment_9_1()); 
-            // InternalRoom.g:11503:1: ( rule__ActorClass__BehaviorDocuAssignment_9_1 )?
-            int alt123=2;
-            int LA123_0 = input.LA(1);
+            // InternalRoom.g:11732:1: ( rule__ActorClass__BehaviorDocuAssignment_9_1 )?
+            int alt126=2;
+            int LA126_0 = input.LA(1);
 
-            if ( (LA123_0==62) ) {
-                alt123=1;
+            if ( (LA126_0==62) ) {
+                alt126=1;
             }
-            switch (alt123) {
+            switch (alt126) {
                 case 1 :
-                    // InternalRoom.g:11503:2: rule__ActorClass__BehaviorDocuAssignment_9_1
+                    // InternalRoom.g:11732:2: rule__ActorClass__BehaviorDocuAssignment_9_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__BehaviorDocuAssignment_9_1();
@@ -32706,14 +33365,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__2"
-    // InternalRoom.g:11513:1: rule__ActorClass__Group_9__2 : rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3 ;
+    // InternalRoom.g:11742:1: rule__ActorClass__Group_9__2 : rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3 ;
     public final void rule__ActorClass__Group_9__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11517:1: ( rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3 )
-            // InternalRoom.g:11518:2: rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3
+            // InternalRoom.g:11746:1: ( rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3 )
+            // InternalRoom.g:11747:2: rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__2__Impl();
@@ -32744,17 +33403,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__2__Impl"
-    // InternalRoom.g:11525:1: rule__ActorClass__Group_9__2__Impl : ( '{' ) ;
+    // InternalRoom.g:11754:1: rule__ActorClass__Group_9__2__Impl : ( '{' ) ;
     public final void rule__ActorClass__Group_9__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11529:1: ( ( '{' ) )
-            // InternalRoom.g:11530:1: ( '{' )
+            // InternalRoom.g:11758:1: ( ( '{' ) )
+            // InternalRoom.g:11759:1: ( '{' )
             {
-            // InternalRoom.g:11530:1: ( '{' )
-            // InternalRoom.g:11531:1: '{'
+            // InternalRoom.g:11759:1: ( '{' )
+            // InternalRoom.g:11760:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_9_2()); 
             match(input,44,FOLLOW_2); 
@@ -32781,14 +33440,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__3"
-    // InternalRoom.g:11544:1: rule__ActorClass__Group_9__3 : rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4 ;
+    // InternalRoom.g:11773:1: rule__ActorClass__Group_9__3 : rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4 ;
     public final void rule__ActorClass__Group_9__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11548:1: ( rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4 )
-            // InternalRoom.g:11549:2: rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4
+            // InternalRoom.g:11777:1: ( rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4 )
+            // InternalRoom.g:11778:2: rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__3__Impl();
@@ -32819,33 +33478,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__3__Impl"
-    // InternalRoom.g:11556:1: rule__ActorClass__Group_9__3__Impl : ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* ) ;
+    // InternalRoom.g:11785:1: rule__ActorClass__Group_9__3__Impl : ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* ) ;
     public final void rule__ActorClass__Group_9__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11560:1: ( ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* ) )
-            // InternalRoom.g:11561:1: ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* )
+            // InternalRoom.g:11789:1: ( ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* ) )
+            // InternalRoom.g:11790:1: ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* )
             {
-            // InternalRoom.g:11561:1: ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* )
-            // InternalRoom.g:11562:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
+            // InternalRoom.g:11790:1: ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* )
+            // InternalRoom.g:11791:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
             {
              before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAssignment_9_3()); 
-            // InternalRoom.g:11563:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
-            loop124:
+            // InternalRoom.g:11792:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
+            loop127:
             do {
-                int alt124=2;
-                int LA124_0 = input.LA(1);
+                int alt127=2;
+                int LA127_0 = input.LA(1);
 
-                if ( (LA124_0==121) ) {
-                    alt124=1;
+                if ( (LA127_0==121) ) {
+                    alt127=1;
                 }
 
 
-                switch (alt124) {
+                switch (alt127) {
             	case 1 :
-            	    // InternalRoom.g:11563:2: rule__ActorClass__BehaviorAnnotationsAssignment_9_3
+            	    // InternalRoom.g:11792:2: rule__ActorClass__BehaviorAnnotationsAssignment_9_3
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ActorClass__BehaviorAnnotationsAssignment_9_3();
@@ -32857,7 +33516,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop124;
+            	    break loop127;
                 }
             } while (true);
 
@@ -32884,14 +33543,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__4"
-    // InternalRoom.g:11573:1: rule__ActorClass__Group_9__4 : rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5 ;
+    // InternalRoom.g:11802:1: rule__ActorClass__Group_9__4 : rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5 ;
     public final void rule__ActorClass__Group_9__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11577:1: ( rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5 )
-            // InternalRoom.g:11578:2: rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5
+            // InternalRoom.g:11806:1: ( rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5 )
+            // InternalRoom.g:11807:2: rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__4__Impl();
@@ -32922,33 +33581,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__4__Impl"
-    // InternalRoom.g:11585:1: rule__ActorClass__Group_9__4__Impl : ( ( rule__ActorClass__Alternatives_9_4 )* ) ;
+    // InternalRoom.g:11814:1: rule__ActorClass__Group_9__4__Impl : ( ( rule__ActorClass__Alternatives_9_4 )* ) ;
     public final void rule__ActorClass__Group_9__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11589:1: ( ( ( rule__ActorClass__Alternatives_9_4 )* ) )
-            // InternalRoom.g:11590:1: ( ( rule__ActorClass__Alternatives_9_4 )* )
+            // InternalRoom.g:11818:1: ( ( ( rule__ActorClass__Alternatives_9_4 )* ) )
+            // InternalRoom.g:11819:1: ( ( rule__ActorClass__Alternatives_9_4 )* )
             {
-            // InternalRoom.g:11590:1: ( ( rule__ActorClass__Alternatives_9_4 )* )
-            // InternalRoom.g:11591:1: ( rule__ActorClass__Alternatives_9_4 )*
+            // InternalRoom.g:11819:1: ( ( rule__ActorClass__Alternatives_9_4 )* )
+            // InternalRoom.g:11820:1: ( rule__ActorClass__Alternatives_9_4 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_9_4()); 
-            // InternalRoom.g:11592:1: ( rule__ActorClass__Alternatives_9_4 )*
-            loop125:
+            // InternalRoom.g:11821:1: ( rule__ActorClass__Alternatives_9_4 )*
+            loop128:
             do {
-                int alt125=2;
-                int LA125_0 = input.LA(1);
+                int alt128=2;
+                int LA128_0 = input.LA(1);
 
-                if ( ((LA125_0>=14 && LA125_0<=15)||LA125_0==64||LA125_0==128) ) {
-                    alt125=1;
+                if ( ((LA128_0>=14 && LA128_0<=15)||LA128_0==64||LA128_0==128) ) {
+                    alt128=1;
                 }
 
 
-                switch (alt125) {
+                switch (alt128) {
             	case 1 :
-            	    // InternalRoom.g:11592:2: rule__ActorClass__Alternatives_9_4
+            	    // InternalRoom.g:11821:2: rule__ActorClass__Alternatives_9_4
             	    {
             	    pushFollow(FOLLOW_59);
             	    rule__ActorClass__Alternatives_9_4();
@@ -32960,7 +33619,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop125;
+            	    break loop128;
                 }
             } while (true);
 
@@ -32987,14 +33646,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__5"
-    // InternalRoom.g:11602:1: rule__ActorClass__Group_9__5 : rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6 ;
+    // InternalRoom.g:11831:1: rule__ActorClass__Group_9__5 : rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6 ;
     public final void rule__ActorClass__Group_9__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11606:1: ( rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6 )
-            // InternalRoom.g:11607:2: rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6
+            // InternalRoom.g:11835:1: ( rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6 )
+            // InternalRoom.g:11836:2: rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__5__Impl();
@@ -33025,29 +33684,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__5__Impl"
-    // InternalRoom.g:11614:1: rule__ActorClass__Group_9__5__Impl : ( ( rule__ActorClass__StateMachineAssignment_9_5 )? ) ;
+    // InternalRoom.g:11843:1: rule__ActorClass__Group_9__5__Impl : ( ( rule__ActorClass__StateMachineAssignment_9_5 )? ) ;
     public final void rule__ActorClass__Group_9__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11618:1: ( ( ( rule__ActorClass__StateMachineAssignment_9_5 )? ) )
-            // InternalRoom.g:11619:1: ( ( rule__ActorClass__StateMachineAssignment_9_5 )? )
+            // InternalRoom.g:11847:1: ( ( ( rule__ActorClass__StateMachineAssignment_9_5 )? ) )
+            // InternalRoom.g:11848:1: ( ( rule__ActorClass__StateMachineAssignment_9_5 )? )
             {
-            // InternalRoom.g:11619:1: ( ( rule__ActorClass__StateMachineAssignment_9_5 )? )
-            // InternalRoom.g:11620:1: ( rule__ActorClass__StateMachineAssignment_9_5 )?
+            // InternalRoom.g:11848:1: ( ( rule__ActorClass__StateMachineAssignment_9_5 )? )
+            // InternalRoom.g:11849:1: ( rule__ActorClass__StateMachineAssignment_9_5 )?
             {
              before(grammarAccess.getActorClassAccess().getStateMachineAssignment_9_5()); 
-            // InternalRoom.g:11621:1: ( rule__ActorClass__StateMachineAssignment_9_5 )?
-            int alt126=2;
-            int LA126_0 = input.LA(1);
+            // InternalRoom.g:11850:1: ( rule__ActorClass__StateMachineAssignment_9_5 )?
+            int alt129=2;
+            int LA129_0 = input.LA(1);
 
-            if ( (LA126_0==94) ) {
-                alt126=1;
+            if ( (LA129_0==94) ) {
+                alt129=1;
             }
-            switch (alt126) {
+            switch (alt129) {
                 case 1 :
-                    // InternalRoom.g:11621:2: rule__ActorClass__StateMachineAssignment_9_5
+                    // InternalRoom.g:11850:2: rule__ActorClass__StateMachineAssignment_9_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StateMachineAssignment_9_5();
@@ -33083,14 +33742,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__6"
-    // InternalRoom.g:11631:1: rule__ActorClass__Group_9__6 : rule__ActorClass__Group_9__6__Impl ;
+    // InternalRoom.g:11860:1: rule__ActorClass__Group_9__6 : rule__ActorClass__Group_9__6__Impl ;
     public final void rule__ActorClass__Group_9__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11635:1: ( rule__ActorClass__Group_9__6__Impl )
-            // InternalRoom.g:11636:2: rule__ActorClass__Group_9__6__Impl
+            // InternalRoom.g:11864:1: ( rule__ActorClass__Group_9__6__Impl )
+            // InternalRoom.g:11865:2: rule__ActorClass__Group_9__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_9__6__Impl();
@@ -33116,17 +33775,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group_9__6__Impl"
-    // InternalRoom.g:11642:1: rule__ActorClass__Group_9__6__Impl : ( '}' ) ;
+    // InternalRoom.g:11871:1: rule__ActorClass__Group_9__6__Impl : ( '}' ) ;
     public final void rule__ActorClass__Group_9__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11646:1: ( ( '}' ) )
-            // InternalRoom.g:11647:1: ( '}' )
+            // InternalRoom.g:11875:1: ( ( '}' ) )
+            // InternalRoom.g:11876:1: ( '}' )
             {
-            // InternalRoom.g:11647:1: ( '}' )
-            // InternalRoom.g:11648:1: '}'
+            // InternalRoom.g:11876:1: ( '}' )
+            // InternalRoom.g:11877:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_9_6()); 
             match(input,45,FOLLOW_2); 
@@ -33153,14 +33812,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__0"
-    // InternalRoom.g:11675:1: rule__Port__Group__0 : rule__Port__Group__0__Impl rule__Port__Group__1 ;
+    // InternalRoom.g:11904:1: rule__Port__Group__0 : rule__Port__Group__0__Impl rule__Port__Group__1 ;
     public final void rule__Port__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11679:1: ( rule__Port__Group__0__Impl rule__Port__Group__1 )
-            // InternalRoom.g:11680:2: rule__Port__Group__0__Impl rule__Port__Group__1
+            // InternalRoom.g:11908:1: ( rule__Port__Group__0__Impl rule__Port__Group__1 )
+            // InternalRoom.g:11909:2: rule__Port__Group__0__Impl rule__Port__Group__1
             {
             pushFollow(FOLLOW_60);
             rule__Port__Group__0__Impl();
@@ -33191,29 +33850,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__0__Impl"
-    // InternalRoom.g:11687:1: rule__Port__Group__0__Impl : ( ( rule__Port__ConjugatedAssignment_0 )? ) ;
+    // InternalRoom.g:11916:1: rule__Port__Group__0__Impl : ( ( rule__Port__ConjugatedAssignment_0 )? ) ;
     public final void rule__Port__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11691:1: ( ( ( rule__Port__ConjugatedAssignment_0 )? ) )
-            // InternalRoom.g:11692:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
+            // InternalRoom.g:11920:1: ( ( ( rule__Port__ConjugatedAssignment_0 )? ) )
+            // InternalRoom.g:11921:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
             {
-            // InternalRoom.g:11692:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
-            // InternalRoom.g:11693:1: ( rule__Port__ConjugatedAssignment_0 )?
+            // InternalRoom.g:11921:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
+            // InternalRoom.g:11922:1: ( rule__Port__ConjugatedAssignment_0 )?
             {
              before(grammarAccess.getPortAccess().getConjugatedAssignment_0()); 
-            // InternalRoom.g:11694:1: ( rule__Port__ConjugatedAssignment_0 )?
-            int alt127=2;
-            int LA127_0 = input.LA(1);
+            // InternalRoom.g:11923:1: ( rule__Port__ConjugatedAssignment_0 )?
+            int alt130=2;
+            int LA130_0 = input.LA(1);
 
-            if ( (LA127_0==70) ) {
-                alt127=1;
+            if ( (LA130_0==70) ) {
+                alt130=1;
             }
-            switch (alt127) {
+            switch (alt130) {
                 case 1 :
-                    // InternalRoom.g:11694:2: rule__Port__ConjugatedAssignment_0
+                    // InternalRoom.g:11923:2: rule__Port__ConjugatedAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__ConjugatedAssignment_0();
@@ -33249,14 +33908,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__1"
-    // InternalRoom.g:11704:1: rule__Port__Group__1 : rule__Port__Group__1__Impl rule__Port__Group__2 ;
+    // InternalRoom.g:11933:1: rule__Port__Group__1 : rule__Port__Group__1__Impl rule__Port__Group__2 ;
     public final void rule__Port__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11708:1: ( rule__Port__Group__1__Impl rule__Port__Group__2 )
-            // InternalRoom.g:11709:2: rule__Port__Group__1__Impl rule__Port__Group__2
+            // InternalRoom.g:11937:1: ( rule__Port__Group__1__Impl rule__Port__Group__2 )
+            // InternalRoom.g:11938:2: rule__Port__Group__1__Impl rule__Port__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__Port__Group__1__Impl();
@@ -33287,17 +33946,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__1__Impl"
-    // InternalRoom.g:11716:1: rule__Port__Group__1__Impl : ( 'Port' ) ;
+    // InternalRoom.g:11945:1: rule__Port__Group__1__Impl : ( 'Port' ) ;
     public final void rule__Port__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11720:1: ( ( 'Port' ) )
-            // InternalRoom.g:11721:1: ( 'Port' )
+            // InternalRoom.g:11949:1: ( ( 'Port' ) )
+            // InternalRoom.g:11950:1: ( 'Port' )
             {
-            // InternalRoom.g:11721:1: ( 'Port' )
-            // InternalRoom.g:11722:1: 'Port'
+            // InternalRoom.g:11950:1: ( 'Port' )
+            // InternalRoom.g:11951:1: 'Port'
             {
              before(grammarAccess.getPortAccess().getPortKeyword_1()); 
             match(input,24,FOLLOW_2); 
@@ -33324,14 +33983,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__2"
-    // InternalRoom.g:11735:1: rule__Port__Group__2 : rule__Port__Group__2__Impl rule__Port__Group__3 ;
+    // InternalRoom.g:11964:1: rule__Port__Group__2 : rule__Port__Group__2__Impl rule__Port__Group__3 ;
     public final void rule__Port__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11739:1: ( rule__Port__Group__2__Impl rule__Port__Group__3 )
-            // InternalRoom.g:11740:2: rule__Port__Group__2__Impl rule__Port__Group__3
+            // InternalRoom.g:11968:1: ( rule__Port__Group__2__Impl rule__Port__Group__3 )
+            // InternalRoom.g:11969:2: rule__Port__Group__2__Impl rule__Port__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__Port__Group__2__Impl();
@@ -33362,21 +34021,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__2__Impl"
-    // InternalRoom.g:11747:1: rule__Port__Group__2__Impl : ( ( rule__Port__NameAssignment_2 ) ) ;
+    // InternalRoom.g:11976:1: rule__Port__Group__2__Impl : ( ( rule__Port__NameAssignment_2 ) ) ;
     public final void rule__Port__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11751:1: ( ( ( rule__Port__NameAssignment_2 ) ) )
-            // InternalRoom.g:11752:1: ( ( rule__Port__NameAssignment_2 ) )
+            // InternalRoom.g:11980:1: ( ( ( rule__Port__NameAssignment_2 ) ) )
+            // InternalRoom.g:11981:1: ( ( rule__Port__NameAssignment_2 ) )
             {
-            // InternalRoom.g:11752:1: ( ( rule__Port__NameAssignment_2 ) )
-            // InternalRoom.g:11753:1: ( rule__Port__NameAssignment_2 )
+            // InternalRoom.g:11981:1: ( ( rule__Port__NameAssignment_2 ) )
+            // InternalRoom.g:11982:1: ( rule__Port__NameAssignment_2 )
             {
              before(grammarAccess.getPortAccess().getNameAssignment_2()); 
-            // InternalRoom.g:11754:1: ( rule__Port__NameAssignment_2 )
-            // InternalRoom.g:11754:2: rule__Port__NameAssignment_2
+            // InternalRoom.g:11983:1: ( rule__Port__NameAssignment_2 )
+            // InternalRoom.g:11983:2: rule__Port__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Port__NameAssignment_2();
@@ -33409,14 +34068,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__3"
-    // InternalRoom.g:11764:1: rule__Port__Group__3 : rule__Port__Group__3__Impl rule__Port__Group__4 ;
+    // InternalRoom.g:11993:1: rule__Port__Group__3 : rule__Port__Group__3__Impl rule__Port__Group__4 ;
     public final void rule__Port__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11768:1: ( rule__Port__Group__3__Impl rule__Port__Group__4 )
-            // InternalRoom.g:11769:2: rule__Port__Group__3__Impl rule__Port__Group__4
+            // InternalRoom.g:11997:1: ( rule__Port__Group__3__Impl rule__Port__Group__4 )
+            // InternalRoom.g:11998:2: rule__Port__Group__3__Impl rule__Port__Group__4
             {
             pushFollow(FOLLOW_28);
             rule__Port__Group__3__Impl();
@@ -33447,29 +34106,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__3__Impl"
-    // InternalRoom.g:11776:1: rule__Port__Group__3__Impl : ( ( rule__Port__MultiplicityAssignment_3 )? ) ;
+    // InternalRoom.g:12005:1: rule__Port__Group__3__Impl : ( ( rule__Port__MultiplicityAssignment_3 )? ) ;
     public final void rule__Port__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11780:1: ( ( ( rule__Port__MultiplicityAssignment_3 )? ) )
-            // InternalRoom.g:11781:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:12009:1: ( ( ( rule__Port__MultiplicityAssignment_3 )? ) )
+            // InternalRoom.g:12010:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
             {
-            // InternalRoom.g:11781:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
-            // InternalRoom.g:11782:1: ( rule__Port__MultiplicityAssignment_3 )?
+            // InternalRoom.g:12010:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:12011:1: ( rule__Port__MultiplicityAssignment_3 )?
             {
              before(grammarAccess.getPortAccess().getMultiplicityAssignment_3()); 
-            // InternalRoom.g:11783:1: ( rule__Port__MultiplicityAssignment_3 )?
-            int alt128=2;
-            int LA128_0 = input.LA(1);
+            // InternalRoom.g:12012:1: ( rule__Port__MultiplicityAssignment_3 )?
+            int alt131=2;
+            int LA131_0 = input.LA(1);
 
-            if ( (LA128_0==62) ) {
-                alt128=1;
+            if ( (LA131_0==62) ) {
+                alt131=1;
             }
-            switch (alt128) {
+            switch (alt131) {
                 case 1 :
-                    // InternalRoom.g:11783:2: rule__Port__MultiplicityAssignment_3
+                    // InternalRoom.g:12012:2: rule__Port__MultiplicityAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__MultiplicityAssignment_3();
@@ -33505,14 +34164,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__4"
-    // InternalRoom.g:11793:1: rule__Port__Group__4 : rule__Port__Group__4__Impl rule__Port__Group__5 ;
+    // InternalRoom.g:12022:1: rule__Port__Group__4 : rule__Port__Group__4__Impl rule__Port__Group__5 ;
     public final void rule__Port__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11797:1: ( rule__Port__Group__4__Impl rule__Port__Group__5 )
-            // InternalRoom.g:11798:2: rule__Port__Group__4__Impl rule__Port__Group__5
+            // InternalRoom.g:12026:1: ( rule__Port__Group__4__Impl rule__Port__Group__5 )
+            // InternalRoom.g:12027:2: rule__Port__Group__4__Impl rule__Port__Group__5
             {
             pushFollow(FOLLOW_3);
             rule__Port__Group__4__Impl();
@@ -33543,17 +34202,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__4__Impl"
-    // InternalRoom.g:11805:1: rule__Port__Group__4__Impl : ( ':' ) ;
+    // InternalRoom.g:12034:1: rule__Port__Group__4__Impl : ( ':' ) ;
     public final void rule__Port__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11809:1: ( ( ':' ) )
-            // InternalRoom.g:11810:1: ( ':' )
+            // InternalRoom.g:12038:1: ( ( ':' ) )
+            // InternalRoom.g:12039:1: ( ':' )
             {
-            // InternalRoom.g:11810:1: ( ':' )
-            // InternalRoom.g:11811:1: ':'
+            // InternalRoom.g:12039:1: ( ':' )
+            // InternalRoom.g:12040:1: ':'
             {
              before(grammarAccess.getPortAccess().getColonKeyword_4()); 
             match(input,46,FOLLOW_2); 
@@ -33580,16 +34239,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__5"
-    // InternalRoom.g:11824:1: rule__Port__Group__5 : rule__Port__Group__5__Impl rule__Port__Group__6 ;
+    // InternalRoom.g:12053:1: rule__Port__Group__5 : rule__Port__Group__5__Impl rule__Port__Group__6 ;
     public final void rule__Port__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11828:1: ( rule__Port__Group__5__Impl rule__Port__Group__6 )
-            // InternalRoom.g:11829:2: rule__Port__Group__5__Impl rule__Port__Group__6
+            // InternalRoom.g:12057:1: ( rule__Port__Group__5__Impl rule__Port__Group__6 )
+            // InternalRoom.g:12058:2: rule__Port__Group__5__Impl rule__Port__Group__6
             {
-            pushFollow(FOLLOW_47);
+            pushFollow(FOLLOW_61);
             rule__Port__Group__5__Impl();
 
             state._fsp--;
@@ -33618,21 +34277,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__5__Impl"
-    // InternalRoom.g:11836:1: rule__Port__Group__5__Impl : ( ( rule__Port__ProtocolAssignment_5 ) ) ;
+    // InternalRoom.g:12065:1: rule__Port__Group__5__Impl : ( ( rule__Port__ProtocolAssignment_5 ) ) ;
     public final void rule__Port__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11840:1: ( ( ( rule__Port__ProtocolAssignment_5 ) ) )
-            // InternalRoom.g:11841:1: ( ( rule__Port__ProtocolAssignment_5 ) )
+            // InternalRoom.g:12069:1: ( ( ( rule__Port__ProtocolAssignment_5 ) ) )
+            // InternalRoom.g:12070:1: ( ( rule__Port__ProtocolAssignment_5 ) )
             {
-            // InternalRoom.g:11841:1: ( ( rule__Port__ProtocolAssignment_5 ) )
-            // InternalRoom.g:11842:1: ( rule__Port__ProtocolAssignment_5 )
+            // InternalRoom.g:12070:1: ( ( rule__Port__ProtocolAssignment_5 ) )
+            // InternalRoom.g:12071:1: ( rule__Port__ProtocolAssignment_5 )
             {
              before(grammarAccess.getPortAccess().getProtocolAssignment_5()); 
-            // InternalRoom.g:11843:1: ( rule__Port__ProtocolAssignment_5 )
-            // InternalRoom.g:11843:2: rule__Port__ProtocolAssignment_5
+            // InternalRoom.g:12072:1: ( rule__Port__ProtocolAssignment_5 )
+            // InternalRoom.g:12072:2: rule__Port__ProtocolAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__Port__ProtocolAssignment_5();
@@ -33665,16 +34324,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__6"
-    // InternalRoom.g:11853:1: rule__Port__Group__6 : rule__Port__Group__6__Impl rule__Port__Group__7 ;
+    // InternalRoom.g:12082:1: rule__Port__Group__6 : rule__Port__Group__6__Impl rule__Port__Group__7 ;
     public final void rule__Port__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11857:1: ( rule__Port__Group__6__Impl rule__Port__Group__7 )
-            // InternalRoom.g:11858:2: rule__Port__Group__6__Impl rule__Port__Group__7
+            // InternalRoom.g:12086:1: ( rule__Port__Group__6__Impl rule__Port__Group__7 )
+            // InternalRoom.g:12087:2: rule__Port__Group__6__Impl rule__Port__Group__7
             {
-            pushFollow(FOLLOW_47);
+            pushFollow(FOLLOW_61);
             rule__Port__Group__6__Impl();
 
             state._fsp--;
@@ -33703,33 +34362,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__6__Impl"
-    // InternalRoom.g:11865:1: rule__Port__Group__6__Impl : ( ( rule__Port__AnnotationsAssignment_6 )* ) ;
+    // InternalRoom.g:12094:1: rule__Port__Group__6__Impl : ( ( rule__Port__AnnotationsAssignment_6 )* ) ;
     public final void rule__Port__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11869:1: ( ( ( rule__Port__AnnotationsAssignment_6 )* ) )
-            // InternalRoom.g:11870:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:12098:1: ( ( ( rule__Port__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:12099:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:11870:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:11871:1: ( rule__Port__AnnotationsAssignment_6 )*
+            // InternalRoom.g:12099:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:12100:1: ( rule__Port__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getPortAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:11872:1: ( rule__Port__AnnotationsAssignment_6 )*
-            loop129:
+            // InternalRoom.g:12101:1: ( rule__Port__AnnotationsAssignment_6 )*
+            loop132:
             do {
-                int alt129=2;
-                int LA129_0 = input.LA(1);
+                int alt132=2;
+                int LA132_0 = input.LA(1);
 
-                if ( (LA129_0==121) ) {
-                    alt129=1;
+                if ( (LA132_0==121) ) {
+                    alt132=1;
                 }
 
 
-                switch (alt129) {
+                switch (alt132) {
             	case 1 :
-            	    // InternalRoom.g:11872:2: rule__Port__AnnotationsAssignment_6
+            	    // InternalRoom.g:12101:2: rule__Port__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__Port__AnnotationsAssignment_6();
@@ -33741,7 +34400,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop129;
+            	    break loop132;
                 }
             } while (true);
 
@@ -33768,14 +34427,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__7"
-    // InternalRoom.g:11882:1: rule__Port__Group__7 : rule__Port__Group__7__Impl ;
+    // InternalRoom.g:12111:1: rule__Port__Group__7 : rule__Port__Group__7__Impl ;
     public final void rule__Port__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11886:1: ( rule__Port__Group__7__Impl )
-            // InternalRoom.g:11887:2: rule__Port__Group__7__Impl
+            // InternalRoom.g:12115:1: ( rule__Port__Group__7__Impl )
+            // InternalRoom.g:12116:2: rule__Port__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Port__Group__7__Impl();
@@ -33801,29 +34460,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__7__Impl"
-    // InternalRoom.g:11893:1: rule__Port__Group__7__Impl : ( ( rule__Port__DocuAssignment_7 )? ) ;
+    // InternalRoom.g:12122:1: rule__Port__Group__7__Impl : ( ( rule__Port__DocuAssignment_7 )? ) ;
     public final void rule__Port__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11897:1: ( ( ( rule__Port__DocuAssignment_7 )? ) )
-            // InternalRoom.g:11898:1: ( ( rule__Port__DocuAssignment_7 )? )
+            // InternalRoom.g:12126:1: ( ( ( rule__Port__DocuAssignment_7 )? ) )
+            // InternalRoom.g:12127:1: ( ( rule__Port__DocuAssignment_7 )? )
             {
-            // InternalRoom.g:11898:1: ( ( rule__Port__DocuAssignment_7 )? )
-            // InternalRoom.g:11899:1: ( rule__Port__DocuAssignment_7 )?
+            // InternalRoom.g:12127:1: ( ( rule__Port__DocuAssignment_7 )? )
+            // InternalRoom.g:12128:1: ( rule__Port__DocuAssignment_7 )?
             {
              before(grammarAccess.getPortAccess().getDocuAssignment_7()); 
-            // InternalRoom.g:11900:1: ( rule__Port__DocuAssignment_7 )?
-            int alt130=2;
-            int LA130_0 = input.LA(1);
+            // InternalRoom.g:12129:1: ( rule__Port__DocuAssignment_7 )?
+            int alt133=2;
+            int LA133_0 = input.LA(1);
 
-            if ( (LA130_0==62) ) {
-                alt130=1;
+            if ( (LA133_0==62) ) {
+                alt133=1;
             }
-            switch (alt130) {
+            switch (alt133) {
                 case 1 :
-                    // InternalRoom.g:11900:2: rule__Port__DocuAssignment_7
+                    // InternalRoom.g:12129:2: rule__Port__DocuAssignment_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__DocuAssignment_7();
@@ -33859,16 +34518,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__0"
-    // InternalRoom.g:11926:1: rule__ExternalPort__Group__0 : rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1 ;
+    // InternalRoom.g:12155:1: rule__ExternalPort__Group__0 : rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1 ;
     public final void rule__ExternalPort__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11930:1: ( rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1 )
-            // InternalRoom.g:11931:2: rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1
+            // InternalRoom.g:12159:1: ( rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1 )
+            // InternalRoom.g:12160:2: rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1
             {
-            pushFollow(FOLLOW_61);
+            pushFollow(FOLLOW_62);
             rule__ExternalPort__Group__0__Impl();
 
             state._fsp--;
@@ -33897,17 +34556,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__0__Impl"
-    // InternalRoom.g:11938:1: rule__ExternalPort__Group__0__Impl : ( 'external' ) ;
+    // InternalRoom.g:12167:1: rule__ExternalPort__Group__0__Impl : ( 'external' ) ;
     public final void rule__ExternalPort__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11942:1: ( ( 'external' ) )
-            // InternalRoom.g:11943:1: ( 'external' )
+            // InternalRoom.g:12171:1: ( ( 'external' ) )
+            // InternalRoom.g:12172:1: ( 'external' )
             {
-            // InternalRoom.g:11943:1: ( 'external' )
-            // InternalRoom.g:11944:1: 'external'
+            // InternalRoom.g:12172:1: ( 'external' )
+            // InternalRoom.g:12173:1: 'external'
             {
              before(grammarAccess.getExternalPortAccess().getExternalKeyword_0()); 
             match(input,77,FOLLOW_2); 
@@ -33934,14 +34593,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__1"
-    // InternalRoom.g:11957:1: rule__ExternalPort__Group__1 : rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2 ;
+    // InternalRoom.g:12186:1: rule__ExternalPort__Group__1 : rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2 ;
     public final void rule__ExternalPort__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11961:1: ( rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2 )
-            // InternalRoom.g:11962:2: rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2
+            // InternalRoom.g:12190:1: ( rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2 )
+            // InternalRoom.g:12191:2: rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ExternalPort__Group__1__Impl();
@@ -33972,17 +34631,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__1__Impl"
-    // InternalRoom.g:11969:1: rule__ExternalPort__Group__1__Impl : ( 'Port' ) ;
+    // InternalRoom.g:12198:1: rule__ExternalPort__Group__1__Impl : ( 'Port' ) ;
     public final void rule__ExternalPort__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11973:1: ( ( 'Port' ) )
-            // InternalRoom.g:11974:1: ( 'Port' )
+            // InternalRoom.g:12202:1: ( ( 'Port' ) )
+            // InternalRoom.g:12203:1: ( 'Port' )
             {
-            // InternalRoom.g:11974:1: ( 'Port' )
-            // InternalRoom.g:11975:1: 'Port'
+            // InternalRoom.g:12203:1: ( 'Port' )
+            // InternalRoom.g:12204:1: 'Port'
             {
              before(grammarAccess.getExternalPortAccess().getPortKeyword_1()); 
             match(input,24,FOLLOW_2); 
@@ -34009,14 +34668,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__2"
-    // InternalRoom.g:11988:1: rule__ExternalPort__Group__2 : rule__ExternalPort__Group__2__Impl ;
+    // InternalRoom.g:12217:1: rule__ExternalPort__Group__2 : rule__ExternalPort__Group__2__Impl ;
     public final void rule__ExternalPort__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:11992:1: ( rule__ExternalPort__Group__2__Impl )
-            // InternalRoom.g:11993:2: rule__ExternalPort__Group__2__Impl
+            // InternalRoom.g:12221:1: ( rule__ExternalPort__Group__2__Impl )
+            // InternalRoom.g:12222:2: rule__ExternalPort__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalPort__Group__2__Impl();
@@ -34042,21 +34701,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__Group__2__Impl"
-    // InternalRoom.g:11999:1: rule__ExternalPort__Group__2__Impl : ( ( rule__ExternalPort__InterfacePortAssignment_2 ) ) ;
+    // InternalRoom.g:12228:1: rule__ExternalPort__Group__2__Impl : ( ( rule__ExternalPort__InterfacePortAssignment_2 ) ) ;
     public final void rule__ExternalPort__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12003:1: ( ( ( rule__ExternalPort__InterfacePortAssignment_2 ) ) )
-            // InternalRoom.g:12004:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
+            // InternalRoom.g:12232:1: ( ( ( rule__ExternalPort__InterfacePortAssignment_2 ) ) )
+            // InternalRoom.g:12233:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
             {
-            // InternalRoom.g:12004:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
-            // InternalRoom.g:12005:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
+            // InternalRoom.g:12233:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
+            // InternalRoom.g:12234:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
             {
              before(grammarAccess.getExternalPortAccess().getInterfacePortAssignment_2()); 
-            // InternalRoom.g:12006:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
-            // InternalRoom.g:12006:2: rule__ExternalPort__InterfacePortAssignment_2
+            // InternalRoom.g:12235:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
+            // InternalRoom.g:12235:2: rule__ExternalPort__InterfacePortAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ExternalPort__InterfacePortAssignment_2();
@@ -34089,14 +34748,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__0"
-    // InternalRoom.g:12022:1: rule__SAP__Group__0 : rule__SAP__Group__0__Impl rule__SAP__Group__1 ;
+    // InternalRoom.g:12251:1: rule__SAP__Group__0 : rule__SAP__Group__0__Impl rule__SAP__Group__1 ;
     public final void rule__SAP__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12026:1: ( rule__SAP__Group__0__Impl rule__SAP__Group__1 )
-            // InternalRoom.g:12027:2: rule__SAP__Group__0__Impl rule__SAP__Group__1
+            // InternalRoom.g:12255:1: ( rule__SAP__Group__0__Impl rule__SAP__Group__1 )
+            // InternalRoom.g:12256:2: rule__SAP__Group__0__Impl rule__SAP__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SAP__Group__0__Impl();
@@ -34127,17 +34786,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__0__Impl"
-    // InternalRoom.g:12034:1: rule__SAP__Group__0__Impl : ( 'SAP' ) ;
+    // InternalRoom.g:12263:1: rule__SAP__Group__0__Impl : ( 'SAP' ) ;
     public final void rule__SAP__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12038:1: ( ( 'SAP' ) )
-            // InternalRoom.g:12039:1: ( 'SAP' )
+            // InternalRoom.g:12267:1: ( ( 'SAP' ) )
+            // InternalRoom.g:12268:1: ( 'SAP' )
             {
-            // InternalRoom.g:12039:1: ( 'SAP' )
-            // InternalRoom.g:12040:1: 'SAP'
+            // InternalRoom.g:12268:1: ( 'SAP' )
+            // InternalRoom.g:12269:1: 'SAP'
             {
              before(grammarAccess.getSAPAccess().getSAPKeyword_0()); 
             match(input,78,FOLLOW_2); 
@@ -34164,14 +34823,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__1"
-    // InternalRoom.g:12053:1: rule__SAP__Group__1 : rule__SAP__Group__1__Impl rule__SAP__Group__2 ;
+    // InternalRoom.g:12282:1: rule__SAP__Group__1 : rule__SAP__Group__1__Impl rule__SAP__Group__2 ;
     public final void rule__SAP__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12057:1: ( rule__SAP__Group__1__Impl rule__SAP__Group__2 )
-            // InternalRoom.g:12058:2: rule__SAP__Group__1__Impl rule__SAP__Group__2
+            // InternalRoom.g:12286:1: ( rule__SAP__Group__1__Impl rule__SAP__Group__2 )
+            // InternalRoom.g:12287:2: rule__SAP__Group__1__Impl rule__SAP__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SAP__Group__1__Impl();
@@ -34202,21 +34861,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__1__Impl"
-    // InternalRoom.g:12065:1: rule__SAP__Group__1__Impl : ( ( rule__SAP__NameAssignment_1 ) ) ;
+    // InternalRoom.g:12294:1: rule__SAP__Group__1__Impl : ( ( rule__SAP__NameAssignment_1 ) ) ;
     public final void rule__SAP__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12069:1: ( ( ( rule__SAP__NameAssignment_1 ) ) )
-            // InternalRoom.g:12070:1: ( ( rule__SAP__NameAssignment_1 ) )
+            // InternalRoom.g:12298:1: ( ( ( rule__SAP__NameAssignment_1 ) ) )
+            // InternalRoom.g:12299:1: ( ( rule__SAP__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12070:1: ( ( rule__SAP__NameAssignment_1 ) )
-            // InternalRoom.g:12071:1: ( rule__SAP__NameAssignment_1 )
+            // InternalRoom.g:12299:1: ( ( rule__SAP__NameAssignment_1 ) )
+            // InternalRoom.g:12300:1: ( rule__SAP__NameAssignment_1 )
             {
              before(grammarAccess.getSAPAccess().getNameAssignment_1()); 
-            // InternalRoom.g:12072:1: ( rule__SAP__NameAssignment_1 )
-            // InternalRoom.g:12072:2: rule__SAP__NameAssignment_1
+            // InternalRoom.g:12301:1: ( rule__SAP__NameAssignment_1 )
+            // InternalRoom.g:12301:2: rule__SAP__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SAP__NameAssignment_1();
@@ -34249,14 +34908,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__2"
-    // InternalRoom.g:12082:1: rule__SAP__Group__2 : rule__SAP__Group__2__Impl rule__SAP__Group__3 ;
+    // InternalRoom.g:12311:1: rule__SAP__Group__2 : rule__SAP__Group__2__Impl rule__SAP__Group__3 ;
     public final void rule__SAP__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12086:1: ( rule__SAP__Group__2__Impl rule__SAP__Group__3 )
-            // InternalRoom.g:12087:2: rule__SAP__Group__2__Impl rule__SAP__Group__3
+            // InternalRoom.g:12315:1: ( rule__SAP__Group__2__Impl rule__SAP__Group__3 )
+            // InternalRoom.g:12316:2: rule__SAP__Group__2__Impl rule__SAP__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SAP__Group__2__Impl();
@@ -34287,17 +34946,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__2__Impl"
-    // InternalRoom.g:12094:1: rule__SAP__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12323:1: rule__SAP__Group__2__Impl : ( ':' ) ;
     public final void rule__SAP__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12098:1: ( ( ':' ) )
-            // InternalRoom.g:12099:1: ( ':' )
+            // InternalRoom.g:12327:1: ( ( ':' ) )
+            // InternalRoom.g:12328:1: ( ':' )
             {
-            // InternalRoom.g:12099:1: ( ':' )
-            // InternalRoom.g:12100:1: ':'
+            // InternalRoom.g:12328:1: ( ':' )
+            // InternalRoom.g:12329:1: ':'
             {
              before(grammarAccess.getSAPAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -34324,14 +34983,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__3"
-    // InternalRoom.g:12113:1: rule__SAP__Group__3 : rule__SAP__Group__3__Impl ;
+    // InternalRoom.g:12342:1: rule__SAP__Group__3 : rule__SAP__Group__3__Impl ;
     public final void rule__SAP__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12117:1: ( rule__SAP__Group__3__Impl )
-            // InternalRoom.g:12118:2: rule__SAP__Group__3__Impl
+            // InternalRoom.g:12346:1: ( rule__SAP__Group__3__Impl )
+            // InternalRoom.g:12347:2: rule__SAP__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SAP__Group__3__Impl();
@@ -34357,21 +35016,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__3__Impl"
-    // InternalRoom.g:12124:1: rule__SAP__Group__3__Impl : ( ( rule__SAP__ProtocolAssignment_3 ) ) ;
+    // InternalRoom.g:12353:1: rule__SAP__Group__3__Impl : ( ( rule__SAP__ProtocolAssignment_3 ) ) ;
     public final void rule__SAP__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12128:1: ( ( ( rule__SAP__ProtocolAssignment_3 ) ) )
-            // InternalRoom.g:12129:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12357:1: ( ( ( rule__SAP__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:12358:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:12129:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
-            // InternalRoom.g:12130:1: ( rule__SAP__ProtocolAssignment_3 )
+            // InternalRoom.g:12358:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12359:1: ( rule__SAP__ProtocolAssignment_3 )
             {
              before(grammarAccess.getSAPAccess().getProtocolAssignment_3()); 
-            // InternalRoom.g:12131:1: ( rule__SAP__ProtocolAssignment_3 )
-            // InternalRoom.g:12131:2: rule__SAP__ProtocolAssignment_3
+            // InternalRoom.g:12360:1: ( rule__SAP__ProtocolAssignment_3 )
+            // InternalRoom.g:12360:2: rule__SAP__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SAP__ProtocolAssignment_3();
@@ -34404,14 +35063,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__0"
-    // InternalRoom.g:12149:1: rule__SPP__Group__0 : rule__SPP__Group__0__Impl rule__SPP__Group__1 ;
+    // InternalRoom.g:12378:1: rule__SPP__Group__0 : rule__SPP__Group__0__Impl rule__SPP__Group__1 ;
     public final void rule__SPP__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12153:1: ( rule__SPP__Group__0__Impl rule__SPP__Group__1 )
-            // InternalRoom.g:12154:2: rule__SPP__Group__0__Impl rule__SPP__Group__1
+            // InternalRoom.g:12382:1: ( rule__SPP__Group__0__Impl rule__SPP__Group__1 )
+            // InternalRoom.g:12383:2: rule__SPP__Group__0__Impl rule__SPP__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SPP__Group__0__Impl();
@@ -34442,17 +35101,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__0__Impl"
-    // InternalRoom.g:12161:1: rule__SPP__Group__0__Impl : ( 'SPP' ) ;
+    // InternalRoom.g:12390:1: rule__SPP__Group__0__Impl : ( 'SPP' ) ;
     public final void rule__SPP__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12165:1: ( ( 'SPP' ) )
-            // InternalRoom.g:12166:1: ( 'SPP' )
+            // InternalRoom.g:12394:1: ( ( 'SPP' ) )
+            // InternalRoom.g:12395:1: ( 'SPP' )
             {
-            // InternalRoom.g:12166:1: ( 'SPP' )
-            // InternalRoom.g:12167:1: 'SPP'
+            // InternalRoom.g:12395:1: ( 'SPP' )
+            // InternalRoom.g:12396:1: 'SPP'
             {
              before(grammarAccess.getSPPAccess().getSPPKeyword_0()); 
             match(input,79,FOLLOW_2); 
@@ -34479,14 +35138,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__1"
-    // InternalRoom.g:12180:1: rule__SPP__Group__1 : rule__SPP__Group__1__Impl rule__SPP__Group__2 ;
+    // InternalRoom.g:12409:1: rule__SPP__Group__1 : rule__SPP__Group__1__Impl rule__SPP__Group__2 ;
     public final void rule__SPP__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12184:1: ( rule__SPP__Group__1__Impl rule__SPP__Group__2 )
-            // InternalRoom.g:12185:2: rule__SPP__Group__1__Impl rule__SPP__Group__2
+            // InternalRoom.g:12413:1: ( rule__SPP__Group__1__Impl rule__SPP__Group__2 )
+            // InternalRoom.g:12414:2: rule__SPP__Group__1__Impl rule__SPP__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SPP__Group__1__Impl();
@@ -34517,21 +35176,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__1__Impl"
-    // InternalRoom.g:12192:1: rule__SPP__Group__1__Impl : ( ( rule__SPP__NameAssignment_1 ) ) ;
+    // InternalRoom.g:12421:1: rule__SPP__Group__1__Impl : ( ( rule__SPP__NameAssignment_1 ) ) ;
     public final void rule__SPP__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12196:1: ( ( ( rule__SPP__NameAssignment_1 ) ) )
-            // InternalRoom.g:12197:1: ( ( rule__SPP__NameAssignment_1 ) )
+            // InternalRoom.g:12425:1: ( ( ( rule__SPP__NameAssignment_1 ) ) )
+            // InternalRoom.g:12426:1: ( ( rule__SPP__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12197:1: ( ( rule__SPP__NameAssignment_1 ) )
-            // InternalRoom.g:12198:1: ( rule__SPP__NameAssignment_1 )
+            // InternalRoom.g:12426:1: ( ( rule__SPP__NameAssignment_1 ) )
+            // InternalRoom.g:12427:1: ( rule__SPP__NameAssignment_1 )
             {
              before(grammarAccess.getSPPAccess().getNameAssignment_1()); 
-            // InternalRoom.g:12199:1: ( rule__SPP__NameAssignment_1 )
-            // InternalRoom.g:12199:2: rule__SPP__NameAssignment_1
+            // InternalRoom.g:12428:1: ( rule__SPP__NameAssignment_1 )
+            // InternalRoom.g:12428:2: rule__SPP__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SPP__NameAssignment_1();
@@ -34564,14 +35223,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__2"
-    // InternalRoom.g:12209:1: rule__SPP__Group__2 : rule__SPP__Group__2__Impl rule__SPP__Group__3 ;
+    // InternalRoom.g:12438:1: rule__SPP__Group__2 : rule__SPP__Group__2__Impl rule__SPP__Group__3 ;
     public final void rule__SPP__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12213:1: ( rule__SPP__Group__2__Impl rule__SPP__Group__3 )
-            // InternalRoom.g:12214:2: rule__SPP__Group__2__Impl rule__SPP__Group__3
+            // InternalRoom.g:12442:1: ( rule__SPP__Group__2__Impl rule__SPP__Group__3 )
+            // InternalRoom.g:12443:2: rule__SPP__Group__2__Impl rule__SPP__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SPP__Group__2__Impl();
@@ -34602,17 +35261,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__2__Impl"
-    // InternalRoom.g:12221:1: rule__SPP__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12450:1: rule__SPP__Group__2__Impl : ( ':' ) ;
     public final void rule__SPP__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12225:1: ( ( ':' ) )
-            // InternalRoom.g:12226:1: ( ':' )
+            // InternalRoom.g:12454:1: ( ( ':' ) )
+            // InternalRoom.g:12455:1: ( ':' )
             {
-            // InternalRoom.g:12226:1: ( ':' )
-            // InternalRoom.g:12227:1: ':'
+            // InternalRoom.g:12455:1: ( ':' )
+            // InternalRoom.g:12456:1: ':'
             {
              before(grammarAccess.getSPPAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -34639,14 +35298,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__3"
-    // InternalRoom.g:12240:1: rule__SPP__Group__3 : rule__SPP__Group__3__Impl ;
+    // InternalRoom.g:12469:1: rule__SPP__Group__3 : rule__SPP__Group__3__Impl ;
     public final void rule__SPP__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12244:1: ( rule__SPP__Group__3__Impl )
-            // InternalRoom.g:12245:2: rule__SPP__Group__3__Impl
+            // InternalRoom.g:12473:1: ( rule__SPP__Group__3__Impl )
+            // InternalRoom.g:12474:2: rule__SPP__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SPP__Group__3__Impl();
@@ -34672,21 +35331,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__3__Impl"
-    // InternalRoom.g:12251:1: rule__SPP__Group__3__Impl : ( ( rule__SPP__ProtocolAssignment_3 ) ) ;
+    // InternalRoom.g:12480:1: rule__SPP__Group__3__Impl : ( ( rule__SPP__ProtocolAssignment_3 ) ) ;
     public final void rule__SPP__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12255:1: ( ( ( rule__SPP__ProtocolAssignment_3 ) ) )
-            // InternalRoom.g:12256:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12484:1: ( ( ( rule__SPP__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:12485:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:12256:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
-            // InternalRoom.g:12257:1: ( rule__SPP__ProtocolAssignment_3 )
+            // InternalRoom.g:12485:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12486:1: ( rule__SPP__ProtocolAssignment_3 )
             {
              before(grammarAccess.getSPPAccess().getProtocolAssignment_3()); 
-            // InternalRoom.g:12258:1: ( rule__SPP__ProtocolAssignment_3 )
-            // InternalRoom.g:12258:2: rule__SPP__ProtocolAssignment_3
+            // InternalRoom.g:12487:1: ( rule__SPP__ProtocolAssignment_3 )
+            // InternalRoom.g:12487:2: rule__SPP__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SPP__ProtocolAssignment_3();
@@ -34719,16 +35378,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__0"
-    // InternalRoom.g:12276:1: rule__ServiceImplementation__Group__0 : rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1 ;
+    // InternalRoom.g:12505:1: rule__ServiceImplementation__Group__0 : rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1 ;
     public final void rule__ServiceImplementation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12280:1: ( rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1 )
-            // InternalRoom.g:12281:2: rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1
+            // InternalRoom.g:12509:1: ( rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1 )
+            // InternalRoom.g:12510:2: rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1
             {
-            pushFollow(FOLLOW_62);
+            pushFollow(FOLLOW_63);
             rule__ServiceImplementation__Group__0__Impl();
 
             state._fsp--;
@@ -34757,17 +35416,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__0__Impl"
-    // InternalRoom.g:12288:1: rule__ServiceImplementation__Group__0__Impl : ( 'ServiceImplementation' ) ;
+    // InternalRoom.g:12517:1: rule__ServiceImplementation__Group__0__Impl : ( 'ServiceImplementation' ) ;
     public final void rule__ServiceImplementation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12292:1: ( ( 'ServiceImplementation' ) )
-            // InternalRoom.g:12293:1: ( 'ServiceImplementation' )
+            // InternalRoom.g:12521:1: ( ( 'ServiceImplementation' ) )
+            // InternalRoom.g:12522:1: ( 'ServiceImplementation' )
             {
-            // InternalRoom.g:12293:1: ( 'ServiceImplementation' )
-            // InternalRoom.g:12294:1: 'ServiceImplementation'
+            // InternalRoom.g:12522:1: ( 'ServiceImplementation' )
+            // InternalRoom.g:12523:1: 'ServiceImplementation'
             {
              before(grammarAccess.getServiceImplementationAccess().getServiceImplementationKeyword_0()); 
             match(input,80,FOLLOW_2); 
@@ -34794,14 +35453,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__1"
-    // InternalRoom.g:12307:1: rule__ServiceImplementation__Group__1 : rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2 ;
+    // InternalRoom.g:12536:1: rule__ServiceImplementation__Group__1 : rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2 ;
     public final void rule__ServiceImplementation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12311:1: ( rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2 )
-            // InternalRoom.g:12312:2: rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2
+            // InternalRoom.g:12540:1: ( rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2 )
+            // InternalRoom.g:12541:2: rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ServiceImplementation__Group__1__Impl();
@@ -34832,17 +35491,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__1__Impl"
-    // InternalRoom.g:12319:1: rule__ServiceImplementation__Group__1__Impl : ( 'of' ) ;
+    // InternalRoom.g:12548:1: rule__ServiceImplementation__Group__1__Impl : ( 'of' ) ;
     public final void rule__ServiceImplementation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12323:1: ( ( 'of' ) )
-            // InternalRoom.g:12324:1: ( 'of' )
+            // InternalRoom.g:12552:1: ( ( 'of' ) )
+            // InternalRoom.g:12553:1: ( 'of' )
             {
-            // InternalRoom.g:12324:1: ( 'of' )
-            // InternalRoom.g:12325:1: 'of'
+            // InternalRoom.g:12553:1: ( 'of' )
+            // InternalRoom.g:12554:1: 'of'
             {
              before(grammarAccess.getServiceImplementationAccess().getOfKeyword_1()); 
             match(input,53,FOLLOW_2); 
@@ -34869,14 +35528,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__2"
-    // InternalRoom.g:12338:1: rule__ServiceImplementation__Group__2 : rule__ServiceImplementation__Group__2__Impl ;
+    // InternalRoom.g:12567:1: rule__ServiceImplementation__Group__2 : rule__ServiceImplementation__Group__2__Impl ;
     public final void rule__ServiceImplementation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12342:1: ( rule__ServiceImplementation__Group__2__Impl )
-            // InternalRoom.g:12343:2: rule__ServiceImplementation__Group__2__Impl
+            // InternalRoom.g:12571:1: ( rule__ServiceImplementation__Group__2__Impl )
+            // InternalRoom.g:12572:2: rule__ServiceImplementation__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ServiceImplementation__Group__2__Impl();
@@ -34902,21 +35561,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__Group__2__Impl"
-    // InternalRoom.g:12349:1: rule__ServiceImplementation__Group__2__Impl : ( ( rule__ServiceImplementation__SppAssignment_2 ) ) ;
+    // InternalRoom.g:12578:1: rule__ServiceImplementation__Group__2__Impl : ( ( rule__ServiceImplementation__SppAssignment_2 ) ) ;
     public final void rule__ServiceImplementation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12353:1: ( ( ( rule__ServiceImplementation__SppAssignment_2 ) ) )
-            // InternalRoom.g:12354:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
+            // InternalRoom.g:12582:1: ( ( ( rule__ServiceImplementation__SppAssignment_2 ) ) )
+            // InternalRoom.g:12583:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
             {
-            // InternalRoom.g:12354:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
-            // InternalRoom.g:12355:1: ( rule__ServiceImplementation__SppAssignment_2 )
+            // InternalRoom.g:12583:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
+            // InternalRoom.g:12584:1: ( rule__ServiceImplementation__SppAssignment_2 )
             {
              before(grammarAccess.getServiceImplementationAccess().getSppAssignment_2()); 
-            // InternalRoom.g:12356:1: ( rule__ServiceImplementation__SppAssignment_2 )
-            // InternalRoom.g:12356:2: rule__ServiceImplementation__SppAssignment_2
+            // InternalRoom.g:12585:1: ( rule__ServiceImplementation__SppAssignment_2 )
+            // InternalRoom.g:12585:2: rule__ServiceImplementation__SppAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ServiceImplementation__SppAssignment_2();
@@ -34949,14 +35608,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__0"
-    // InternalRoom.g:12372:1: rule__LogicalSystem__Group__0 : rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1 ;
+    // InternalRoom.g:12601:1: rule__LogicalSystem__Group__0 : rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1 ;
     public final void rule__LogicalSystem__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12376:1: ( rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1 )
-            // InternalRoom.g:12377:2: rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1
+            // InternalRoom.g:12605:1: ( rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1 )
+            // InternalRoom.g:12606:2: rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__LogicalSystem__Group__0__Impl();
@@ -34987,17 +35646,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__0__Impl"
-    // InternalRoom.g:12384:1: rule__LogicalSystem__Group__0__Impl : ( 'LogicalSystem' ) ;
+    // InternalRoom.g:12613:1: rule__LogicalSystem__Group__0__Impl : ( 'LogicalSystem' ) ;
     public final void rule__LogicalSystem__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12388:1: ( ( 'LogicalSystem' ) )
-            // InternalRoom.g:12389:1: ( 'LogicalSystem' )
+            // InternalRoom.g:12617:1: ( ( 'LogicalSystem' ) )
+            // InternalRoom.g:12618:1: ( 'LogicalSystem' )
             {
-            // InternalRoom.g:12389:1: ( 'LogicalSystem' )
-            // InternalRoom.g:12390:1: 'LogicalSystem'
+            // InternalRoom.g:12618:1: ( 'LogicalSystem' )
+            // InternalRoom.g:12619:1: 'LogicalSystem'
             {
              before(grammarAccess.getLogicalSystemAccess().getLogicalSystemKeyword_0()); 
             match(input,23,FOLLOW_2); 
@@ -35024,14 +35683,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__1"
-    // InternalRoom.g:12403:1: rule__LogicalSystem__Group__1 : rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2 ;
+    // InternalRoom.g:12632:1: rule__LogicalSystem__Group__1 : rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2 ;
     public final void rule__LogicalSystem__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12407:1: ( rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2 )
-            // InternalRoom.g:12408:2: rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2
+            // InternalRoom.g:12636:1: ( rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2 )
+            // InternalRoom.g:12637:2: rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__LogicalSystem__Group__1__Impl();
@@ -35062,21 +35721,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__1__Impl"
-    // InternalRoom.g:12415:1: rule__LogicalSystem__Group__1__Impl : ( ( rule__LogicalSystem__NameAssignment_1 ) ) ;
+    // InternalRoom.g:12644:1: rule__LogicalSystem__Group__1__Impl : ( ( rule__LogicalSystem__NameAssignment_1 ) ) ;
     public final void rule__LogicalSystem__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12419:1: ( ( ( rule__LogicalSystem__NameAssignment_1 ) ) )
-            // InternalRoom.g:12420:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
+            // InternalRoom.g:12648:1: ( ( ( rule__LogicalSystem__NameAssignment_1 ) ) )
+            // InternalRoom.g:12649:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12420:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
-            // InternalRoom.g:12421:1: ( rule__LogicalSystem__NameAssignment_1 )
+            // InternalRoom.g:12649:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
+            // InternalRoom.g:12650:1: ( rule__LogicalSystem__NameAssignment_1 )
             {
              before(grammarAccess.getLogicalSystemAccess().getNameAssignment_1()); 
-            // InternalRoom.g:12422:1: ( rule__LogicalSystem__NameAssignment_1 )
-            // InternalRoom.g:12422:2: rule__LogicalSystem__NameAssignment_1
+            // InternalRoom.g:12651:1: ( rule__LogicalSystem__NameAssignment_1 )
+            // InternalRoom.g:12651:2: rule__LogicalSystem__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LogicalSystem__NameAssignment_1();
@@ -35109,14 +35768,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__2"
-    // InternalRoom.g:12432:1: rule__LogicalSystem__Group__2 : rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3 ;
+    // InternalRoom.g:12661:1: rule__LogicalSystem__Group__2 : rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3 ;
     public final void rule__LogicalSystem__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12436:1: ( rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3 )
-            // InternalRoom.g:12437:2: rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3
+            // InternalRoom.g:12665:1: ( rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3 )
+            // InternalRoom.g:12666:2: rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__LogicalSystem__Group__2__Impl();
@@ -35147,29 +35806,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__2__Impl"
-    // InternalRoom.g:12444:1: rule__LogicalSystem__Group__2__Impl : ( ( rule__LogicalSystem__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:12673:1: rule__LogicalSystem__Group__2__Impl : ( ( rule__LogicalSystem__DocuAssignment_2 )? ) ;
     public final void rule__LogicalSystem__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12448:1: ( ( ( rule__LogicalSystem__DocuAssignment_2 )? ) )
-            // InternalRoom.g:12449:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
+            // InternalRoom.g:12677:1: ( ( ( rule__LogicalSystem__DocuAssignment_2 )? ) )
+            // InternalRoom.g:12678:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:12449:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
-            // InternalRoom.g:12450:1: ( rule__LogicalSystem__DocuAssignment_2 )?
+            // InternalRoom.g:12678:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
+            // InternalRoom.g:12679:1: ( rule__LogicalSystem__DocuAssignment_2 )?
             {
              before(grammarAccess.getLogicalSystemAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:12451:1: ( rule__LogicalSystem__DocuAssignment_2 )?
-            int alt131=2;
-            int LA131_0 = input.LA(1);
+            // InternalRoom.g:12680:1: ( rule__LogicalSystem__DocuAssignment_2 )?
+            int alt134=2;
+            int LA134_0 = input.LA(1);
 
-            if ( (LA131_0==62) ) {
-                alt131=1;
+            if ( (LA134_0==62) ) {
+                alt134=1;
             }
-            switch (alt131) {
+            switch (alt134) {
                 case 1 :
-                    // InternalRoom.g:12451:2: rule__LogicalSystem__DocuAssignment_2
+                    // InternalRoom.g:12680:2: rule__LogicalSystem__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__DocuAssignment_2();
@@ -35205,16 +35864,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__3"
-    // InternalRoom.g:12461:1: rule__LogicalSystem__Group__3 : rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4 ;
+    // InternalRoom.g:12690:1: rule__LogicalSystem__Group__3 : rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4 ;
     public final void rule__LogicalSystem__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12465:1: ( rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4 )
-            // InternalRoom.g:12466:2: rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4
+            // InternalRoom.g:12694:1: ( rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4 )
+            // InternalRoom.g:12695:2: rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4
             {
-            pushFollow(FOLLOW_63);
+            pushFollow(FOLLOW_64);
             rule__LogicalSystem__Group__3__Impl();
 
             state._fsp--;
@@ -35243,17 +35902,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__3__Impl"
-    // InternalRoom.g:12473:1: rule__LogicalSystem__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:12702:1: rule__LogicalSystem__Group__3__Impl : ( '{' ) ;
     public final void rule__LogicalSystem__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12477:1: ( ( '{' ) )
-            // InternalRoom.g:12478:1: ( '{' )
+            // InternalRoom.g:12706:1: ( ( '{' ) )
+            // InternalRoom.g:12707:1: ( '{' )
             {
-            // InternalRoom.g:12478:1: ( '{' )
-            // InternalRoom.g:12479:1: '{'
+            // InternalRoom.g:12707:1: ( '{' )
+            // InternalRoom.g:12708:1: '{'
             {
              before(grammarAccess.getLogicalSystemAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -35280,16 +35939,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__4"
-    // InternalRoom.g:12492:1: rule__LogicalSystem__Group__4 : rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5 ;
+    // InternalRoom.g:12721:1: rule__LogicalSystem__Group__4 : rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5 ;
     public final void rule__LogicalSystem__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12496:1: ( rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5 )
-            // InternalRoom.g:12497:2: rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5
+            // InternalRoom.g:12725:1: ( rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5 )
+            // InternalRoom.g:12726:2: rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5
             {
-            pushFollow(FOLLOW_63);
+            pushFollow(FOLLOW_64);
             rule__LogicalSystem__Group__4__Impl();
 
             state._fsp--;
@@ -35318,33 +35977,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__4__Impl"
-    // InternalRoom.g:12504:1: rule__LogicalSystem__Group__4__Impl : ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* ) ;
+    // InternalRoom.g:12733:1: rule__LogicalSystem__Group__4__Impl : ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* ) ;
     public final void rule__LogicalSystem__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12508:1: ( ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* ) )
-            // InternalRoom.g:12509:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:12737:1: ( ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:12738:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:12509:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:12510:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
+            // InternalRoom.g:12738:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:12739:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getLogicalSystemAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:12511:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
-            loop132:
+            // InternalRoom.g:12740:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
+            loop135:
             do {
-                int alt132=2;
-                int LA132_0 = input.LA(1);
+                int alt135=2;
+                int LA135_0 = input.LA(1);
 
-                if ( (LA132_0==121) ) {
-                    alt132=1;
+                if ( (LA135_0==121) ) {
+                    alt135=1;
                 }
 
 
-                switch (alt132) {
+                switch (alt135) {
             	case 1 :
-            	    // InternalRoom.g:12511:2: rule__LogicalSystem__AnnotationsAssignment_4
+            	    // InternalRoom.g:12740:2: rule__LogicalSystem__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__LogicalSystem__AnnotationsAssignment_4();
@@ -35356,7 +36015,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop132;
+            	    break loop135;
                 }
             } while (true);
 
@@ -35383,16 +36042,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__5"
-    // InternalRoom.g:12521:1: rule__LogicalSystem__Group__5 : rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6 ;
+    // InternalRoom.g:12750:1: rule__LogicalSystem__Group__5 : rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6 ;
     public final void rule__LogicalSystem__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12525:1: ( rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6 )
-            // InternalRoom.g:12526:2: rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6
+            // InternalRoom.g:12754:1: ( rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6 )
+            // InternalRoom.g:12755:2: rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6
             {
-            pushFollow(FOLLOW_63);
+            pushFollow(FOLLOW_64);
             rule__LogicalSystem__Group__5__Impl();
 
             state._fsp--;
@@ -35421,35 +36080,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__5__Impl"
-    // InternalRoom.g:12533:1: rule__LogicalSystem__Group__5__Impl : ( ( rule__LogicalSystem__Alternatives_5 )* ) ;
+    // InternalRoom.g:12762:1: rule__LogicalSystem__Group__5__Impl : ( ( rule__LogicalSystem__Alternatives_5 )* ) ;
     public final void rule__LogicalSystem__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12537:1: ( ( ( rule__LogicalSystem__Alternatives_5 )* ) )
-            // InternalRoom.g:12538:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
+            // InternalRoom.g:12766:1: ( ( ( rule__LogicalSystem__Alternatives_5 )* ) )
+            // InternalRoom.g:12767:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
             {
-            // InternalRoom.g:12538:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
-            // InternalRoom.g:12539:1: ( rule__LogicalSystem__Alternatives_5 )*
+            // InternalRoom.g:12767:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
+            // InternalRoom.g:12768:1: ( rule__LogicalSystem__Alternatives_5 )*
             {
              before(grammarAccess.getLogicalSystemAccess().getAlternatives_5()); 
-            // InternalRoom.g:12540:1: ( rule__LogicalSystem__Alternatives_5 )*
-            loop133:
+            // InternalRoom.g:12769:1: ( rule__LogicalSystem__Alternatives_5 )*
+            loop136:
             do {
-                int alt133=2;
-                int LA133_0 = input.LA(1);
+                int alt136=2;
+                int LA136_0 = input.LA(1);
 
-                if ( (LA133_0==81||LA133_0==85||LA133_0==89) ) {
-                    alt133=1;
+                if ( (LA136_0==81||LA136_0==85||LA136_0==89) ) {
+                    alt136=1;
                 }
 
 
-                switch (alt133) {
+                switch (alt136) {
             	case 1 :
-            	    // InternalRoom.g:12540:2: rule__LogicalSystem__Alternatives_5
+            	    // InternalRoom.g:12769:2: rule__LogicalSystem__Alternatives_5
             	    {
-            	    pushFollow(FOLLOW_64);
+            	    pushFollow(FOLLOW_65);
             	    rule__LogicalSystem__Alternatives_5();
 
             	    state._fsp--;
@@ -35459,7 +36118,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop133;
+            	    break loop136;
                 }
             } while (true);
 
@@ -35486,14 +36145,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__6"
-    // InternalRoom.g:12550:1: rule__LogicalSystem__Group__6 : rule__LogicalSystem__Group__6__Impl ;
+    // InternalRoom.g:12779:1: rule__LogicalSystem__Group__6 : rule__LogicalSystem__Group__6__Impl ;
     public final void rule__LogicalSystem__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12554:1: ( rule__LogicalSystem__Group__6__Impl )
-            // InternalRoom.g:12555:2: rule__LogicalSystem__Group__6__Impl
+            // InternalRoom.g:12783:1: ( rule__LogicalSystem__Group__6__Impl )
+            // InternalRoom.g:12784:2: rule__LogicalSystem__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LogicalSystem__Group__6__Impl();
@@ -35519,17 +36178,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__6__Impl"
-    // InternalRoom.g:12561:1: rule__LogicalSystem__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:12790:1: rule__LogicalSystem__Group__6__Impl : ( '}' ) ;
     public final void rule__LogicalSystem__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12565:1: ( ( '}' ) )
-            // InternalRoom.g:12566:1: ( '}' )
+            // InternalRoom.g:12794:1: ( ( '}' ) )
+            // InternalRoom.g:12795:1: ( '}' )
             {
-            // InternalRoom.g:12566:1: ( '}' )
-            // InternalRoom.g:12567:1: '}'
+            // InternalRoom.g:12795:1: ( '}' )
+            // InternalRoom.g:12796:1: '}'
             {
              before(grammarAccess.getLogicalSystemAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -35556,14 +36215,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__0"
-    // InternalRoom.g:12594:1: rule__SubSystemRef__Group__0 : rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1 ;
+    // InternalRoom.g:12823:1: rule__SubSystemRef__Group__0 : rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1 ;
     public final void rule__SubSystemRef__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12598:1: ( rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1 )
-            // InternalRoom.g:12599:2: rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1
+            // InternalRoom.g:12827:1: ( rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1 )
+            // InternalRoom.g:12828:2: rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemRef__Group__0__Impl();
@@ -35594,17 +36253,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__0__Impl"
-    // InternalRoom.g:12606:1: rule__SubSystemRef__Group__0__Impl : ( 'SubSystemRef' ) ;
+    // InternalRoom.g:12835:1: rule__SubSystemRef__Group__0__Impl : ( 'SubSystemRef' ) ;
     public final void rule__SubSystemRef__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12610:1: ( ( 'SubSystemRef' ) )
-            // InternalRoom.g:12611:1: ( 'SubSystemRef' )
+            // InternalRoom.g:12839:1: ( ( 'SubSystemRef' ) )
+            // InternalRoom.g:12840:1: ( 'SubSystemRef' )
             {
-            // InternalRoom.g:12611:1: ( 'SubSystemRef' )
-            // InternalRoom.g:12612:1: 'SubSystemRef'
+            // InternalRoom.g:12840:1: ( 'SubSystemRef' )
+            // InternalRoom.g:12841:1: 'SubSystemRef'
             {
              before(grammarAccess.getSubSystemRefAccess().getSubSystemRefKeyword_0()); 
             match(input,81,FOLLOW_2); 
@@ -35631,14 +36290,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__1"
-    // InternalRoom.g:12625:1: rule__SubSystemRef__Group__1 : rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2 ;
+    // InternalRoom.g:12854:1: rule__SubSystemRef__Group__1 : rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2 ;
     public final void rule__SubSystemRef__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12629:1: ( rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2 )
-            // InternalRoom.g:12630:2: rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2
+            // InternalRoom.g:12858:1: ( rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2 )
+            // InternalRoom.g:12859:2: rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SubSystemRef__Group__1__Impl();
@@ -35669,21 +36328,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__1__Impl"
-    // InternalRoom.g:12637:1: rule__SubSystemRef__Group__1__Impl : ( ( rule__SubSystemRef__NameAssignment_1 ) ) ;
+    // InternalRoom.g:12866:1: rule__SubSystemRef__Group__1__Impl : ( ( rule__SubSystemRef__NameAssignment_1 ) ) ;
     public final void rule__SubSystemRef__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12641:1: ( ( ( rule__SubSystemRef__NameAssignment_1 ) ) )
-            // InternalRoom.g:12642:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
+            // InternalRoom.g:12870:1: ( ( ( rule__SubSystemRef__NameAssignment_1 ) ) )
+            // InternalRoom.g:12871:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12642:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
-            // InternalRoom.g:12643:1: ( rule__SubSystemRef__NameAssignment_1 )
+            // InternalRoom.g:12871:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
+            // InternalRoom.g:12872:1: ( rule__SubSystemRef__NameAssignment_1 )
             {
              before(grammarAccess.getSubSystemRefAccess().getNameAssignment_1()); 
-            // InternalRoom.g:12644:1: ( rule__SubSystemRef__NameAssignment_1 )
-            // InternalRoom.g:12644:2: rule__SubSystemRef__NameAssignment_1
+            // InternalRoom.g:12873:1: ( rule__SubSystemRef__NameAssignment_1 )
+            // InternalRoom.g:12873:2: rule__SubSystemRef__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__NameAssignment_1();
@@ -35716,14 +36375,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__2"
-    // InternalRoom.g:12654:1: rule__SubSystemRef__Group__2 : rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3 ;
+    // InternalRoom.g:12883:1: rule__SubSystemRef__Group__2 : rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3 ;
     public final void rule__SubSystemRef__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12658:1: ( rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3 )
-            // InternalRoom.g:12659:2: rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3
+            // InternalRoom.g:12887:1: ( rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3 )
+            // InternalRoom.g:12888:2: rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemRef__Group__2__Impl();
@@ -35754,17 +36413,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__2__Impl"
-    // InternalRoom.g:12666:1: rule__SubSystemRef__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12895:1: rule__SubSystemRef__Group__2__Impl : ( ':' ) ;
     public final void rule__SubSystemRef__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12670:1: ( ( ':' ) )
-            // InternalRoom.g:12671:1: ( ':' )
+            // InternalRoom.g:12899:1: ( ( ':' ) )
+            // InternalRoom.g:12900:1: ( ':' )
             {
-            // InternalRoom.g:12671:1: ( ':' )
-            // InternalRoom.g:12672:1: ':'
+            // InternalRoom.g:12900:1: ( ':' )
+            // InternalRoom.g:12901:1: ':'
             {
              before(grammarAccess.getSubSystemRefAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -35791,14 +36450,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__3"
-    // InternalRoom.g:12685:1: rule__SubSystemRef__Group__3 : rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4 ;
+    // InternalRoom.g:12914:1: rule__SubSystemRef__Group__3 : rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4 ;
     public final void rule__SubSystemRef__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12689:1: ( rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4 )
-            // InternalRoom.g:12690:2: rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4
+            // InternalRoom.g:12918:1: ( rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4 )
+            // InternalRoom.g:12919:2: rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4
             {
             pushFollow(FOLLOW_14);
             rule__SubSystemRef__Group__3__Impl();
@@ -35829,21 +36488,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__3__Impl"
-    // InternalRoom.g:12697:1: rule__SubSystemRef__Group__3__Impl : ( ( rule__SubSystemRef__TypeAssignment_3 ) ) ;
+    // InternalRoom.g:12926:1: rule__SubSystemRef__Group__3__Impl : ( ( rule__SubSystemRef__TypeAssignment_3 ) ) ;
     public final void rule__SubSystemRef__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12701:1: ( ( ( rule__SubSystemRef__TypeAssignment_3 ) ) )
-            // InternalRoom.g:12702:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
+            // InternalRoom.g:12930:1: ( ( ( rule__SubSystemRef__TypeAssignment_3 ) ) )
+            // InternalRoom.g:12931:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
             {
-            // InternalRoom.g:12702:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
-            // InternalRoom.g:12703:1: ( rule__SubSystemRef__TypeAssignment_3 )
+            // InternalRoom.g:12931:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
+            // InternalRoom.g:12932:1: ( rule__SubSystemRef__TypeAssignment_3 )
             {
              before(grammarAccess.getSubSystemRefAccess().getTypeAssignment_3()); 
-            // InternalRoom.g:12704:1: ( rule__SubSystemRef__TypeAssignment_3 )
-            // InternalRoom.g:12704:2: rule__SubSystemRef__TypeAssignment_3
+            // InternalRoom.g:12933:1: ( rule__SubSystemRef__TypeAssignment_3 )
+            // InternalRoom.g:12933:2: rule__SubSystemRef__TypeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__TypeAssignment_3();
@@ -35876,14 +36535,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__4"
-    // InternalRoom.g:12714:1: rule__SubSystemRef__Group__4 : rule__SubSystemRef__Group__4__Impl ;
+    // InternalRoom.g:12943:1: rule__SubSystemRef__Group__4 : rule__SubSystemRef__Group__4__Impl ;
     public final void rule__SubSystemRef__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12718:1: ( rule__SubSystemRef__Group__4__Impl )
-            // InternalRoom.g:12719:2: rule__SubSystemRef__Group__4__Impl
+            // InternalRoom.g:12947:1: ( rule__SubSystemRef__Group__4__Impl )
+            // InternalRoom.g:12948:2: rule__SubSystemRef__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__Group__4__Impl();
@@ -35909,29 +36568,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__4__Impl"
-    // InternalRoom.g:12725:1: rule__SubSystemRef__Group__4__Impl : ( ( rule__SubSystemRef__DocuAssignment_4 )? ) ;
+    // InternalRoom.g:12954:1: rule__SubSystemRef__Group__4__Impl : ( ( rule__SubSystemRef__DocuAssignment_4 )? ) ;
     public final void rule__SubSystemRef__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12729:1: ( ( ( rule__SubSystemRef__DocuAssignment_4 )? ) )
-            // InternalRoom.g:12730:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
+            // InternalRoom.g:12958:1: ( ( ( rule__SubSystemRef__DocuAssignment_4 )? ) )
+            // InternalRoom.g:12959:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
             {
-            // InternalRoom.g:12730:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
-            // InternalRoom.g:12731:1: ( rule__SubSystemRef__DocuAssignment_4 )?
+            // InternalRoom.g:12959:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
+            // InternalRoom.g:12960:1: ( rule__SubSystemRef__DocuAssignment_4 )?
             {
              before(grammarAccess.getSubSystemRefAccess().getDocuAssignment_4()); 
-            // InternalRoom.g:12732:1: ( rule__SubSystemRef__DocuAssignment_4 )?
-            int alt134=2;
-            int LA134_0 = input.LA(1);
+            // InternalRoom.g:12961:1: ( rule__SubSystemRef__DocuAssignment_4 )?
+            int alt137=2;
+            int LA137_0 = input.LA(1);
 
-            if ( (LA134_0==62) ) {
-                alt134=1;
+            if ( (LA137_0==62) ) {
+                alt137=1;
             }
-            switch (alt134) {
+            switch (alt137) {
                 case 1 :
-                    // InternalRoom.g:12732:2: rule__SubSystemRef__DocuAssignment_4
+                    // InternalRoom.g:12961:2: rule__SubSystemRef__DocuAssignment_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemRef__DocuAssignment_4();
@@ -35967,14 +36626,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__0"
-    // InternalRoom.g:12752:1: rule__SubSystemClass__Group__0 : rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1 ;
+    // InternalRoom.g:12981:1: rule__SubSystemClass__Group__0 : rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1 ;
     public final void rule__SubSystemClass__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12756:1: ( rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1 )
-            // InternalRoom.g:12757:2: rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1
+            // InternalRoom.g:12985:1: ( rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1 )
+            // InternalRoom.g:12986:2: rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemClass__Group__0__Impl();
@@ -36005,17 +36664,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__0__Impl"
-    // InternalRoom.g:12764:1: rule__SubSystemClass__Group__0__Impl : ( 'SubSystemClass' ) ;
+    // InternalRoom.g:12993:1: rule__SubSystemClass__Group__0__Impl : ( 'SubSystemClass' ) ;
     public final void rule__SubSystemClass__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12768:1: ( ( 'SubSystemClass' ) )
-            // InternalRoom.g:12769:1: ( 'SubSystemClass' )
+            // InternalRoom.g:12997:1: ( ( 'SubSystemClass' ) )
+            // InternalRoom.g:12998:1: ( 'SubSystemClass' )
             {
-            // InternalRoom.g:12769:1: ( 'SubSystemClass' )
-            // InternalRoom.g:12770:1: 'SubSystemClass'
+            // InternalRoom.g:12998:1: ( 'SubSystemClass' )
+            // InternalRoom.g:12999:1: 'SubSystemClass'
             {
              before(grammarAccess.getSubSystemClassAccess().getSubSystemClassKeyword_0()); 
             match(input,22,FOLLOW_2); 
@@ -36042,14 +36701,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__1"
-    // InternalRoom.g:12783:1: rule__SubSystemClass__Group__1 : rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2 ;
+    // InternalRoom.g:13012:1: rule__SubSystemClass__Group__1 : rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2 ;
     public final void rule__SubSystemClass__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12787:1: ( rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2 )
-            // InternalRoom.g:12788:2: rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2
+            // InternalRoom.g:13016:1: ( rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2 )
+            // InternalRoom.g:13017:2: rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__SubSystemClass__Group__1__Impl();
@@ -36080,21 +36739,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__1__Impl"
-    // InternalRoom.g:12795:1: rule__SubSystemClass__Group__1__Impl : ( ( rule__SubSystemClass__NameAssignment_1 ) ) ;
+    // InternalRoom.g:13024:1: rule__SubSystemClass__Group__1__Impl : ( ( rule__SubSystemClass__NameAssignment_1 ) ) ;
     public final void rule__SubSystemClass__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12799:1: ( ( ( rule__SubSystemClass__NameAssignment_1 ) ) )
-            // InternalRoom.g:12800:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
+            // InternalRoom.g:13028:1: ( ( ( rule__SubSystemClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:13029:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12800:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
-            // InternalRoom.g:12801:1: ( rule__SubSystemClass__NameAssignment_1 )
+            // InternalRoom.g:13029:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
+            // InternalRoom.g:13030:1: ( rule__SubSystemClass__NameAssignment_1 )
             {
              before(grammarAccess.getSubSystemClassAccess().getNameAssignment_1()); 
-            // InternalRoom.g:12802:1: ( rule__SubSystemClass__NameAssignment_1 )
-            // InternalRoom.g:12802:2: rule__SubSystemClass__NameAssignment_1
+            // InternalRoom.g:13031:1: ( rule__SubSystemClass__NameAssignment_1 )
+            // InternalRoom.g:13031:2: rule__SubSystemClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__NameAssignment_1();
@@ -36127,14 +36786,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__2"
-    // InternalRoom.g:12812:1: rule__SubSystemClass__Group__2 : rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3 ;
+    // InternalRoom.g:13041:1: rule__SubSystemClass__Group__2 : rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3 ;
     public final void rule__SubSystemClass__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12816:1: ( rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3 )
-            // InternalRoom.g:12817:2: rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3
+            // InternalRoom.g:13045:1: ( rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3 )
+            // InternalRoom.g:13046:2: rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__SubSystemClass__Group__2__Impl();
@@ -36165,29 +36824,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__2__Impl"
-    // InternalRoom.g:12824:1: rule__SubSystemClass__Group__2__Impl : ( ( rule__SubSystemClass__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:13053:1: rule__SubSystemClass__Group__2__Impl : ( ( rule__SubSystemClass__DocuAssignment_2 )? ) ;
     public final void rule__SubSystemClass__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12828:1: ( ( ( rule__SubSystemClass__DocuAssignment_2 )? ) )
-            // InternalRoom.g:12829:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
+            // InternalRoom.g:13057:1: ( ( ( rule__SubSystemClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:13058:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:12829:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
-            // InternalRoom.g:12830:1: ( rule__SubSystemClass__DocuAssignment_2 )?
+            // InternalRoom.g:13058:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
+            // InternalRoom.g:13059:1: ( rule__SubSystemClass__DocuAssignment_2 )?
             {
              before(grammarAccess.getSubSystemClassAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:12831:1: ( rule__SubSystemClass__DocuAssignment_2 )?
-            int alt135=2;
-            int LA135_0 = input.LA(1);
+            // InternalRoom.g:13060:1: ( rule__SubSystemClass__DocuAssignment_2 )?
+            int alt138=2;
+            int LA138_0 = input.LA(1);
 
-            if ( (LA135_0==62) ) {
-                alt135=1;
+            if ( (LA138_0==62) ) {
+                alt138=1;
             }
-            switch (alt135) {
+            switch (alt138) {
                 case 1 :
-                    // InternalRoom.g:12831:2: rule__SubSystemClass__DocuAssignment_2
+                    // InternalRoom.g:13060:2: rule__SubSystemClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__DocuAssignment_2();
@@ -36223,16 +36882,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__3"
-    // InternalRoom.g:12841:1: rule__SubSystemClass__Group__3 : rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4 ;
+    // InternalRoom.g:13070:1: rule__SubSystemClass__Group__3 : rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4 ;
     public final void rule__SubSystemClass__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12845:1: ( rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4 )
-            // InternalRoom.g:12846:2: rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4
+            // InternalRoom.g:13074:1: ( rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4 )
+            // InternalRoom.g:13075:2: rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__3__Impl();
 
             state._fsp--;
@@ -36261,17 +36920,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__3__Impl"
-    // InternalRoom.g:12853:1: rule__SubSystemClass__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:13082:1: rule__SubSystemClass__Group__3__Impl : ( '{' ) ;
     public final void rule__SubSystemClass__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12857:1: ( ( '{' ) )
-            // InternalRoom.g:12858:1: ( '{' )
+            // InternalRoom.g:13086:1: ( ( '{' ) )
+            // InternalRoom.g:13087:1: ( '{' )
             {
-            // InternalRoom.g:12858:1: ( '{' )
-            // InternalRoom.g:12859:1: '{'
+            // InternalRoom.g:13087:1: ( '{' )
+            // InternalRoom.g:13088:1: '{'
             {
              before(grammarAccess.getSubSystemClassAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -36298,16 +36957,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__4"
-    // InternalRoom.g:12872:1: rule__SubSystemClass__Group__4 : rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5 ;
+    // InternalRoom.g:13101:1: rule__SubSystemClass__Group__4 : rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5 ;
     public final void rule__SubSystemClass__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12876:1: ( rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5 )
-            // InternalRoom.g:12877:2: rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5
+            // InternalRoom.g:13105:1: ( rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5 )
+            // InternalRoom.g:13106:2: rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__4__Impl();
 
             state._fsp--;
@@ -36336,33 +36995,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__4__Impl"
-    // InternalRoom.g:12884:1: rule__SubSystemClass__Group__4__Impl : ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* ) ;
+    // InternalRoom.g:13113:1: rule__SubSystemClass__Group__4__Impl : ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* ) ;
     public final void rule__SubSystemClass__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12888:1: ( ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* ) )
-            // InternalRoom.g:12889:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:13117:1: ( ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:13118:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:12889:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:12890:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
+            // InternalRoom.g:13118:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:13119:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getSubSystemClassAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:12891:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
-            loop136:
+            // InternalRoom.g:13120:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
+            loop139:
             do {
-                int alt136=2;
-                int LA136_0 = input.LA(1);
+                int alt139=2;
+                int LA139_0 = input.LA(1);
 
-                if ( (LA136_0==121) ) {
-                    alt136=1;
+                if ( (LA139_0==121) ) {
+                    alt139=1;
                 }
 
 
-                switch (alt136) {
+                switch (alt139) {
             	case 1 :
-            	    // InternalRoom.g:12891:2: rule__SubSystemClass__AnnotationsAssignment_4
+            	    // InternalRoom.g:13120:2: rule__SubSystemClass__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__SubSystemClass__AnnotationsAssignment_4();
@@ -36374,7 +37033,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop136;
+            	    break loop139;
                 }
             } while (true);
 
@@ -36401,16 +37060,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__5"
-    // InternalRoom.g:12901:1: rule__SubSystemClass__Group__5 : rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6 ;
+    // InternalRoom.g:13130:1: rule__SubSystemClass__Group__5 : rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6 ;
     public final void rule__SubSystemClass__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12905:1: ( rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6 )
-            // InternalRoom.g:12906:2: rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6
+            // InternalRoom.g:13134:1: ( rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6 )
+            // InternalRoom.g:13135:2: rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__5__Impl();
 
             state._fsp--;
@@ -36439,29 +37098,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__5__Impl"
-    // InternalRoom.g:12913:1: rule__SubSystemClass__Group__5__Impl : ( ( rule__SubSystemClass__Group_5__0 )? ) ;
+    // InternalRoom.g:13142:1: rule__SubSystemClass__Group__5__Impl : ( ( rule__SubSystemClass__Group_5__0 )? ) ;
     public final void rule__SubSystemClass__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12917:1: ( ( ( rule__SubSystemClass__Group_5__0 )? ) )
-            // InternalRoom.g:12918:1: ( ( rule__SubSystemClass__Group_5__0 )? )
+            // InternalRoom.g:13146:1: ( ( ( rule__SubSystemClass__Group_5__0 )? ) )
+            // InternalRoom.g:13147:1: ( ( rule__SubSystemClass__Group_5__0 )? )
             {
-            // InternalRoom.g:12918:1: ( ( rule__SubSystemClass__Group_5__0 )? )
-            // InternalRoom.g:12919:1: ( rule__SubSystemClass__Group_5__0 )?
+            // InternalRoom.g:13147:1: ( ( rule__SubSystemClass__Group_5__0 )? )
+            // InternalRoom.g:13148:1: ( rule__SubSystemClass__Group_5__0 )?
             {
              before(grammarAccess.getSubSystemClassAccess().getGroup_5()); 
-            // InternalRoom.g:12920:1: ( rule__SubSystemClass__Group_5__0 )?
-            int alt137=2;
-            int LA137_0 = input.LA(1);
+            // InternalRoom.g:13149:1: ( rule__SubSystemClass__Group_5__0 )?
+            int alt140=2;
+            int LA140_0 = input.LA(1);
 
-            if ( (LA137_0==58) ) {
-                alt137=1;
+            if ( (LA140_0==58) ) {
+                alt140=1;
             }
-            switch (alt137) {
+            switch (alt140) {
                 case 1 :
-                    // InternalRoom.g:12920:2: rule__SubSystemClass__Group_5__0
+                    // InternalRoom.g:13149:2: rule__SubSystemClass__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_5__0();
@@ -36497,16 +37156,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__6"
-    // InternalRoom.g:12930:1: rule__SubSystemClass__Group__6 : rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7 ;
+    // InternalRoom.g:13159:1: rule__SubSystemClass__Group__6 : rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7 ;
     public final void rule__SubSystemClass__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12934:1: ( rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7 )
-            // InternalRoom.g:12935:2: rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7
+            // InternalRoom.g:13163:1: ( rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7 )
+            // InternalRoom.g:13164:2: rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__6__Impl();
 
             state._fsp--;
@@ -36535,29 +37194,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__6__Impl"
-    // InternalRoom.g:12942:1: rule__SubSystemClass__Group__6__Impl : ( ( rule__SubSystemClass__Group_6__0 )? ) ;
+    // InternalRoom.g:13171:1: rule__SubSystemClass__Group__6__Impl : ( ( rule__SubSystemClass__Group_6__0 )? ) ;
     public final void rule__SubSystemClass__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12946:1: ( ( ( rule__SubSystemClass__Group_6__0 )? ) )
-            // InternalRoom.g:12947:1: ( ( rule__SubSystemClass__Group_6__0 )? )
+            // InternalRoom.g:13175:1: ( ( ( rule__SubSystemClass__Group_6__0 )? ) )
+            // InternalRoom.g:13176:1: ( ( rule__SubSystemClass__Group_6__0 )? )
             {
-            // InternalRoom.g:12947:1: ( ( rule__SubSystemClass__Group_6__0 )? )
-            // InternalRoom.g:12948:1: ( rule__SubSystemClass__Group_6__0 )?
+            // InternalRoom.g:13176:1: ( ( rule__SubSystemClass__Group_6__0 )? )
+            // InternalRoom.g:13177:1: ( rule__SubSystemClass__Group_6__0 )?
             {
              before(grammarAccess.getSubSystemClassAccess().getGroup_6()); 
-            // InternalRoom.g:12949:1: ( rule__SubSystemClass__Group_6__0 )?
-            int alt138=2;
-            int LA138_0 = input.LA(1);
+            // InternalRoom.g:13178:1: ( rule__SubSystemClass__Group_6__0 )?
+            int alt141=2;
+            int LA141_0 = input.LA(1);
 
-            if ( (LA138_0==59) ) {
-                alt138=1;
+            if ( (LA141_0==59) ) {
+                alt141=1;
             }
-            switch (alt138) {
+            switch (alt141) {
                 case 1 :
-                    // InternalRoom.g:12949:2: rule__SubSystemClass__Group_6__0
+                    // InternalRoom.g:13178:2: rule__SubSystemClass__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_6__0();
@@ -36593,16 +37252,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__7"
-    // InternalRoom.g:12959:1: rule__SubSystemClass__Group__7 : rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8 ;
+    // InternalRoom.g:13188:1: rule__SubSystemClass__Group__7 : rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8 ;
     public final void rule__SubSystemClass__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12963:1: ( rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8 )
-            // InternalRoom.g:12964:2: rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8
+            // InternalRoom.g:13192:1: ( rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8 )
+            // InternalRoom.g:13193:2: rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__7__Impl();
 
             state._fsp--;
@@ -36631,29 +37290,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__7__Impl"
-    // InternalRoom.g:12971:1: rule__SubSystemClass__Group__7__Impl : ( ( rule__SubSystemClass__Group_7__0 )? ) ;
+    // InternalRoom.g:13200:1: rule__SubSystemClass__Group__7__Impl : ( ( rule__SubSystemClass__Group_7__0 )? ) ;
     public final void rule__SubSystemClass__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12975:1: ( ( ( rule__SubSystemClass__Group_7__0 )? ) )
-            // InternalRoom.g:12976:1: ( ( rule__SubSystemClass__Group_7__0 )? )
+            // InternalRoom.g:13204:1: ( ( ( rule__SubSystemClass__Group_7__0 )? ) )
+            // InternalRoom.g:13205:1: ( ( rule__SubSystemClass__Group_7__0 )? )
             {
-            // InternalRoom.g:12976:1: ( ( rule__SubSystemClass__Group_7__0 )? )
-            // InternalRoom.g:12977:1: ( rule__SubSystemClass__Group_7__0 )?
+            // InternalRoom.g:13205:1: ( ( rule__SubSystemClass__Group_7__0 )? )
+            // InternalRoom.g:13206:1: ( rule__SubSystemClass__Group_7__0 )?
             {
              before(grammarAccess.getSubSystemClassAccess().getGroup_7()); 
-            // InternalRoom.g:12978:1: ( rule__SubSystemClass__Group_7__0 )?
-            int alt139=2;
-            int LA139_0 = input.LA(1);
+            // InternalRoom.g:13207:1: ( rule__SubSystemClass__Group_7__0 )?
+            int alt142=2;
+            int LA142_0 = input.LA(1);
 
-            if ( (LA139_0==60) ) {
-                alt139=1;
+            if ( (LA142_0==60) ) {
+                alt142=1;
             }
-            switch (alt139) {
+            switch (alt142) {
                 case 1 :
-                    // InternalRoom.g:12978:2: rule__SubSystemClass__Group_7__0
+                    // InternalRoom.g:13207:2: rule__SubSystemClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_7__0();
@@ -36689,16 +37348,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__8"
-    // InternalRoom.g:12988:1: rule__SubSystemClass__Group__8 : rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9 ;
+    // InternalRoom.g:13217:1: rule__SubSystemClass__Group__8 : rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9 ;
     public final void rule__SubSystemClass__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:12992:1: ( rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9 )
-            // InternalRoom.g:12993:2: rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9
+            // InternalRoom.g:13221:1: ( rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9 )
+            // InternalRoom.g:13222:2: rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9
             {
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             rule__SubSystemClass__Group__8__Impl();
 
             state._fsp--;
@@ -36727,35 +37386,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__8__Impl"
-    // InternalRoom.g:13000:1: rule__SubSystemClass__Group__8__Impl : ( ( rule__SubSystemClass__Alternatives_8 )* ) ;
+    // InternalRoom.g:13229:1: rule__SubSystemClass__Group__8__Impl : ( ( rule__SubSystemClass__Alternatives_8 )* ) ;
     public final void rule__SubSystemClass__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13004:1: ( ( ( rule__SubSystemClass__Alternatives_8 )* ) )
-            // InternalRoom.g:13005:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
+            // InternalRoom.g:13233:1: ( ( ( rule__SubSystemClass__Alternatives_8 )* ) )
+            // InternalRoom.g:13234:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
             {
-            // InternalRoom.g:13005:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
-            // InternalRoom.g:13006:1: ( rule__SubSystemClass__Alternatives_8 )*
+            // InternalRoom.g:13234:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
+            // InternalRoom.g:13235:1: ( rule__SubSystemClass__Alternatives_8 )*
             {
              before(grammarAccess.getSubSystemClassAccess().getAlternatives_8()); 
-            // InternalRoom.g:13007:1: ( rule__SubSystemClass__Alternatives_8 )*
-            loop140:
+            // InternalRoom.g:13236:1: ( rule__SubSystemClass__Alternatives_8 )*
+            loop143:
             do {
-                int alt140=2;
-                int LA140_0 = input.LA(1);
+                int alt143=2;
+                int LA143_0 = input.LA(1);
 
-                if ( (LA140_0==24||(LA140_0>=36 && LA140_0<=37)||LA140_0==70||LA140_0==79||(LA140_0>=82 && LA140_0<=83)||LA140_0==85||LA140_0==89||LA140_0==93) ) {
-                    alt140=1;
+                if ( (LA143_0==24||(LA143_0>=36 && LA143_0<=37)||LA143_0==70||LA143_0==79||(LA143_0>=82 && LA143_0<=83)||LA143_0==85||LA143_0==89||LA143_0==93) ) {
+                    alt143=1;
                 }
 
 
-                switch (alt140) {
+                switch (alt143) {
             	case 1 :
-            	    // InternalRoom.g:13007:2: rule__SubSystemClass__Alternatives_8
+            	    // InternalRoom.g:13236:2: rule__SubSystemClass__Alternatives_8
             	    {
-            	    pushFollow(FOLLOW_66);
+            	    pushFollow(FOLLOW_67);
             	    rule__SubSystemClass__Alternatives_8();
 
             	    state._fsp--;
@@ -36765,7 +37424,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop140;
+            	    break loop143;
                 }
             } while (true);
 
@@ -36792,14 +37451,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__9"
-    // InternalRoom.g:13017:1: rule__SubSystemClass__Group__9 : rule__SubSystemClass__Group__9__Impl ;
+    // InternalRoom.g:13246:1: rule__SubSystemClass__Group__9 : rule__SubSystemClass__Group__9__Impl ;
     public final void rule__SubSystemClass__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13021:1: ( rule__SubSystemClass__Group__9__Impl )
-            // InternalRoom.g:13022:2: rule__SubSystemClass__Group__9__Impl
+            // InternalRoom.g:13250:1: ( rule__SubSystemClass__Group__9__Impl )
+            // InternalRoom.g:13251:2: rule__SubSystemClass__Group__9__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group__9__Impl();
@@ -36825,17 +37484,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__9__Impl"
-    // InternalRoom.g:13028:1: rule__SubSystemClass__Group__9__Impl : ( '}' ) ;
+    // InternalRoom.g:13257:1: rule__SubSystemClass__Group__9__Impl : ( '}' ) ;
     public final void rule__SubSystemClass__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13032:1: ( ( '}' ) )
-            // InternalRoom.g:13033:1: ( '}' )
+            // InternalRoom.g:13261:1: ( ( '}' ) )
+            // InternalRoom.g:13262:1: ( '}' )
             {
-            // InternalRoom.g:13033:1: ( '}' )
-            // InternalRoom.g:13034:1: '}'
+            // InternalRoom.g:13262:1: ( '}' )
+            // InternalRoom.g:13263:1: '}'
             {
              before(grammarAccess.getSubSystemClassAccess().getRightCurlyBracketKeyword_9()); 
             match(input,45,FOLLOW_2); 
@@ -36862,14 +37521,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_5__0"
-    // InternalRoom.g:13067:1: rule__SubSystemClass__Group_5__0 : rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1 ;
+    // InternalRoom.g:13296:1: rule__SubSystemClass__Group_5__0 : rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1 ;
     public final void rule__SubSystemClass__Group_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13071:1: ( rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1 )
-            // InternalRoom.g:13072:2: rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1
+            // InternalRoom.g:13300:1: ( rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1 )
+            // InternalRoom.g:13301:2: rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_5__0__Impl();
@@ -36900,17 +37559,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_5__0__Impl"
-    // InternalRoom.g:13079:1: rule__SubSystemClass__Group_5__0__Impl : ( 'usercode1' ) ;
+    // InternalRoom.g:13308:1: rule__SubSystemClass__Group_5__0__Impl : ( 'usercode1' ) ;
     public final void rule__SubSystemClass__Group_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13083:1: ( ( 'usercode1' ) )
-            // InternalRoom.g:13084:1: ( 'usercode1' )
+            // InternalRoom.g:13312:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:13313:1: ( 'usercode1' )
             {
-            // InternalRoom.g:13084:1: ( 'usercode1' )
-            // InternalRoom.g:13085:1: 'usercode1'
+            // InternalRoom.g:13313:1: ( 'usercode1' )
+            // InternalRoom.g:13314:1: 'usercode1'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode1Keyword_5_0()); 
             match(input,58,FOLLOW_2); 
@@ -36937,14 +37596,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_5__1"
-    // InternalRoom.g:13098:1: rule__SubSystemClass__Group_5__1 : rule__SubSystemClass__Group_5__1__Impl ;
+    // InternalRoom.g:13327:1: rule__SubSystemClass__Group_5__1 : rule__SubSystemClass__Group_5__1__Impl ;
     public final void rule__SubSystemClass__Group_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13102:1: ( rule__SubSystemClass__Group_5__1__Impl )
-            // InternalRoom.g:13103:2: rule__SubSystemClass__Group_5__1__Impl
+            // InternalRoom.g:13331:1: ( rule__SubSystemClass__Group_5__1__Impl )
+            // InternalRoom.g:13332:2: rule__SubSystemClass__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_5__1__Impl();
@@ -36970,21 +37629,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_5__1__Impl"
-    // InternalRoom.g:13109:1: rule__SubSystemClass__Group_5__1__Impl : ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) ) ;
+    // InternalRoom.g:13338:1: rule__SubSystemClass__Group_5__1__Impl : ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) ) ;
     public final void rule__SubSystemClass__Group_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13113:1: ( ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) ) )
-            // InternalRoom.g:13114:1: ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) )
+            // InternalRoom.g:13342:1: ( ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) ) )
+            // InternalRoom.g:13343:1: ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) )
             {
-            // InternalRoom.g:13114:1: ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) )
-            // InternalRoom.g:13115:1: ( rule__SubSystemClass__UserCode1Assignment_5_1 )
+            // InternalRoom.g:13343:1: ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) )
+            // InternalRoom.g:13344:1: ( rule__SubSystemClass__UserCode1Assignment_5_1 )
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode1Assignment_5_1()); 
-            // InternalRoom.g:13116:1: ( rule__SubSystemClass__UserCode1Assignment_5_1 )
-            // InternalRoom.g:13116:2: rule__SubSystemClass__UserCode1Assignment_5_1
+            // InternalRoom.g:13345:1: ( rule__SubSystemClass__UserCode1Assignment_5_1 )
+            // InternalRoom.g:13345:2: rule__SubSystemClass__UserCode1Assignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode1Assignment_5_1();
@@ -37017,14 +37676,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_6__0"
-    // InternalRoom.g:13130:1: rule__SubSystemClass__Group_6__0 : rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1 ;
+    // InternalRoom.g:13359:1: rule__SubSystemClass__Group_6__0 : rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1 ;
     public final void rule__SubSystemClass__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13134:1: ( rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1 )
-            // InternalRoom.g:13135:2: rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1
+            // InternalRoom.g:13363:1: ( rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1 )
+            // InternalRoom.g:13364:2: rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_6__0__Impl();
@@ -37055,17 +37714,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_6__0__Impl"
-    // InternalRoom.g:13142:1: rule__SubSystemClass__Group_6__0__Impl : ( 'usercode2' ) ;
+    // InternalRoom.g:13371:1: rule__SubSystemClass__Group_6__0__Impl : ( 'usercode2' ) ;
     public final void rule__SubSystemClass__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13146:1: ( ( 'usercode2' ) )
-            // InternalRoom.g:13147:1: ( 'usercode2' )
+            // InternalRoom.g:13375:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:13376:1: ( 'usercode2' )
             {
-            // InternalRoom.g:13147:1: ( 'usercode2' )
-            // InternalRoom.g:13148:1: 'usercode2'
+            // InternalRoom.g:13376:1: ( 'usercode2' )
+            // InternalRoom.g:13377:1: 'usercode2'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode2Keyword_6_0()); 
             match(input,59,FOLLOW_2); 
@@ -37092,14 +37751,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_6__1"
-    // InternalRoom.g:13161:1: rule__SubSystemClass__Group_6__1 : rule__SubSystemClass__Group_6__1__Impl ;
+    // InternalRoom.g:13390:1: rule__SubSystemClass__Group_6__1 : rule__SubSystemClass__Group_6__1__Impl ;
     public final void rule__SubSystemClass__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13165:1: ( rule__SubSystemClass__Group_6__1__Impl )
-            // InternalRoom.g:13166:2: rule__SubSystemClass__Group_6__1__Impl
+            // InternalRoom.g:13394:1: ( rule__SubSystemClass__Group_6__1__Impl )
+            // InternalRoom.g:13395:2: rule__SubSystemClass__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_6__1__Impl();
@@ -37125,21 +37784,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_6__1__Impl"
-    // InternalRoom.g:13172:1: rule__SubSystemClass__Group_6__1__Impl : ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) ) ;
+    // InternalRoom.g:13401:1: rule__SubSystemClass__Group_6__1__Impl : ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) ) ;
     public final void rule__SubSystemClass__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13176:1: ( ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) ) )
-            // InternalRoom.g:13177:1: ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) )
+            // InternalRoom.g:13405:1: ( ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) ) )
+            // InternalRoom.g:13406:1: ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) )
             {
-            // InternalRoom.g:13177:1: ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) )
-            // InternalRoom.g:13178:1: ( rule__SubSystemClass__UserCode2Assignment_6_1 )
+            // InternalRoom.g:13406:1: ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) )
+            // InternalRoom.g:13407:1: ( rule__SubSystemClass__UserCode2Assignment_6_1 )
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode2Assignment_6_1()); 
-            // InternalRoom.g:13179:1: ( rule__SubSystemClass__UserCode2Assignment_6_1 )
-            // InternalRoom.g:13179:2: rule__SubSystemClass__UserCode2Assignment_6_1
+            // InternalRoom.g:13408:1: ( rule__SubSystemClass__UserCode2Assignment_6_1 )
+            // InternalRoom.g:13408:2: rule__SubSystemClass__UserCode2Assignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode2Assignment_6_1();
@@ -37172,14 +37831,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_7__0"
-    // InternalRoom.g:13193:1: rule__SubSystemClass__Group_7__0 : rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1 ;
+    // InternalRoom.g:13422:1: rule__SubSystemClass__Group_7__0 : rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1 ;
     public final void rule__SubSystemClass__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13197:1: ( rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1 )
-            // InternalRoom.g:13198:2: rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1
+            // InternalRoom.g:13426:1: ( rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1 )
+            // InternalRoom.g:13427:2: rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_7__0__Impl();
@@ -37210,17 +37869,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_7__0__Impl"
-    // InternalRoom.g:13205:1: rule__SubSystemClass__Group_7__0__Impl : ( 'usercode3' ) ;
+    // InternalRoom.g:13434:1: rule__SubSystemClass__Group_7__0__Impl : ( 'usercode3' ) ;
     public final void rule__SubSystemClass__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13209:1: ( ( 'usercode3' ) )
-            // InternalRoom.g:13210:1: ( 'usercode3' )
+            // InternalRoom.g:13438:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:13439:1: ( 'usercode3' )
             {
-            // InternalRoom.g:13210:1: ( 'usercode3' )
-            // InternalRoom.g:13211:1: 'usercode3'
+            // InternalRoom.g:13439:1: ( 'usercode3' )
+            // InternalRoom.g:13440:1: 'usercode3'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode3Keyword_7_0()); 
             match(input,60,FOLLOW_2); 
@@ -37247,14 +37906,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_7__1"
-    // InternalRoom.g:13224:1: rule__SubSystemClass__Group_7__1 : rule__SubSystemClass__Group_7__1__Impl ;
+    // InternalRoom.g:13453:1: rule__SubSystemClass__Group_7__1 : rule__SubSystemClass__Group_7__1__Impl ;
     public final void rule__SubSystemClass__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13228:1: ( rule__SubSystemClass__Group_7__1__Impl )
-            // InternalRoom.g:13229:2: rule__SubSystemClass__Group_7__1__Impl
+            // InternalRoom.g:13457:1: ( rule__SubSystemClass__Group_7__1__Impl )
+            // InternalRoom.g:13458:2: rule__SubSystemClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_7__1__Impl();
@@ -37280,21 +37939,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group_7__1__Impl"
-    // InternalRoom.g:13235:1: rule__SubSystemClass__Group_7__1__Impl : ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) ) ;
+    // InternalRoom.g:13464:1: rule__SubSystemClass__Group_7__1__Impl : ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) ) ;
     public final void rule__SubSystemClass__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13239:1: ( ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) ) )
-            // InternalRoom.g:13240:1: ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) )
+            // InternalRoom.g:13468:1: ( ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) ) )
+            // InternalRoom.g:13469:1: ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) )
             {
-            // InternalRoom.g:13240:1: ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) )
-            // InternalRoom.g:13241:1: ( rule__SubSystemClass__UserCode3Assignment_7_1 )
+            // InternalRoom.g:13469:1: ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) )
+            // InternalRoom.g:13470:1: ( rule__SubSystemClass__UserCode3Assignment_7_1 )
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode3Assignment_7_1()); 
-            // InternalRoom.g:13242:1: ( rule__SubSystemClass__UserCode3Assignment_7_1 )
-            // InternalRoom.g:13242:2: rule__SubSystemClass__UserCode3Assignment_7_1
+            // InternalRoom.g:13471:1: ( rule__SubSystemClass__UserCode3Assignment_7_1 )
+            // InternalRoom.g:13471:2: rule__SubSystemClass__UserCode3Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode3Assignment_7_1();
@@ -37327,14 +37986,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__Group__0"
-    // InternalRoom.g:13256:1: rule__LogicalThread__Group__0 : rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1 ;
+    // InternalRoom.g:13485:1: rule__LogicalThread__Group__0 : rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1 ;
     public final void rule__LogicalThread__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13260:1: ( rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1 )
-            // InternalRoom.g:13261:2: rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1
+            // InternalRoom.g:13489:1: ( rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1 )
+            // InternalRoom.g:13490:2: rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__LogicalThread__Group__0__Impl();
@@ -37365,17 +38024,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__Group__0__Impl"
-    // InternalRoom.g:13268:1: rule__LogicalThread__Group__0__Impl : ( 'LogicalThread' ) ;
+    // InternalRoom.g:13497:1: rule__LogicalThread__Group__0__Impl : ( 'LogicalThread' ) ;
     public final void rule__LogicalThread__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13272:1: ( ( 'LogicalThread' ) )
-            // InternalRoom.g:13273:1: ( 'LogicalThread' )
+            // InternalRoom.g:13501:1: ( ( 'LogicalThread' ) )
+            // InternalRoom.g:13502:1: ( 'LogicalThread' )
             {
-            // InternalRoom.g:13273:1: ( 'LogicalThread' )
-            // InternalRoom.g:13274:1: 'LogicalThread'
+            // InternalRoom.g:13502:1: ( 'LogicalThread' )
+            // InternalRoom.g:13503:1: 'LogicalThread'
             {
              before(grammarAccess.getLogicalThreadAccess().getLogicalThreadKeyword_0()); 
             match(input,82,FOLLOW_2); 
@@ -37402,14 +38061,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__Group__1"
-    // InternalRoom.g:13287:1: rule__LogicalThread__Group__1 : rule__LogicalThread__Group__1__Impl ;
+    // InternalRoom.g:13516:1: rule__LogicalThread__Group__1 : rule__LogicalThread__Group__1__Impl ;
     public final void rule__LogicalThread__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13291:1: ( rule__LogicalThread__Group__1__Impl )
-            // InternalRoom.g:13292:2: rule__LogicalThread__Group__1__Impl
+            // InternalRoom.g:13520:1: ( rule__LogicalThread__Group__1__Impl )
+            // InternalRoom.g:13521:2: rule__LogicalThread__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LogicalThread__Group__1__Impl();
@@ -37435,21 +38094,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__Group__1__Impl"
-    // InternalRoom.g:13298:1: rule__LogicalThread__Group__1__Impl : ( ( rule__LogicalThread__NameAssignment_1 ) ) ;
+    // InternalRoom.g:13527:1: rule__LogicalThread__Group__1__Impl : ( ( rule__LogicalThread__NameAssignment_1 ) ) ;
     public final void rule__LogicalThread__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13302:1: ( ( ( rule__LogicalThread__NameAssignment_1 ) ) )
-            // InternalRoom.g:13303:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
+            // InternalRoom.g:13531:1: ( ( ( rule__LogicalThread__NameAssignment_1 ) ) )
+            // InternalRoom.g:13532:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
             {
-            // InternalRoom.g:13303:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
-            // InternalRoom.g:13304:1: ( rule__LogicalThread__NameAssignment_1 )
+            // InternalRoom.g:13532:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
+            // InternalRoom.g:13533:1: ( rule__LogicalThread__NameAssignment_1 )
             {
              before(grammarAccess.getLogicalThreadAccess().getNameAssignment_1()); 
-            // InternalRoom.g:13305:1: ( rule__LogicalThread__NameAssignment_1 )
-            // InternalRoom.g:13305:2: rule__LogicalThread__NameAssignment_1
+            // InternalRoom.g:13534:1: ( rule__LogicalThread__NameAssignment_1 )
+            // InternalRoom.g:13534:2: rule__LogicalThread__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LogicalThread__NameAssignment_1();
@@ -37482,14 +38141,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__0"
-    // InternalRoom.g:13319:1: rule__ActorInstanceMapping__Group__0 : rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1 ;
+    // InternalRoom.g:13548:1: rule__ActorInstanceMapping__Group__0 : rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1 ;
     public final void rule__ActorInstanceMapping__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13323:1: ( rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1 )
-            // InternalRoom.g:13324:2: rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1
+            // InternalRoom.g:13552:1: ( rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1 )
+            // InternalRoom.g:13553:2: rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ActorInstanceMapping__Group__0__Impl();
@@ -37520,17 +38179,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__0__Impl"
-    // InternalRoom.g:13331:1: rule__ActorInstanceMapping__Group__0__Impl : ( 'ActorInstanceMapping' ) ;
+    // InternalRoom.g:13560:1: rule__ActorInstanceMapping__Group__0__Impl : ( 'ActorInstanceMapping' ) ;
     public final void rule__ActorInstanceMapping__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13335:1: ( ( 'ActorInstanceMapping' ) )
-            // InternalRoom.g:13336:1: ( 'ActorInstanceMapping' )
+            // InternalRoom.g:13564:1: ( ( 'ActorInstanceMapping' ) )
+            // InternalRoom.g:13565:1: ( 'ActorInstanceMapping' )
             {
-            // InternalRoom.g:13336:1: ( 'ActorInstanceMapping' )
-            // InternalRoom.g:13337:1: 'ActorInstanceMapping'
+            // InternalRoom.g:13565:1: ( 'ActorInstanceMapping' )
+            // InternalRoom.g:13566:1: 'ActorInstanceMapping'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingKeyword_0()); 
             match(input,83,FOLLOW_2); 
@@ -37557,14 +38216,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__1"
-    // InternalRoom.g:13350:1: rule__ActorInstanceMapping__Group__1 : rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2 ;
+    // InternalRoom.g:13579:1: rule__ActorInstanceMapping__Group__1 : rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2 ;
     public final void rule__ActorInstanceMapping__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13354:1: ( rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2 )
-            // InternalRoom.g:13355:2: rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2
+            // InternalRoom.g:13583:1: ( rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2 )
+            // InternalRoom.g:13584:2: rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2
             {
             pushFollow(FOLLOW_11);
             rule__ActorInstanceMapping__Group__1__Impl();
@@ -37595,21 +38254,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__1__Impl"
-    // InternalRoom.g:13362:1: rule__ActorInstanceMapping__Group__1__Impl : ( ( rule__ActorInstanceMapping__PathAssignment_1 ) ) ;
+    // InternalRoom.g:13591:1: rule__ActorInstanceMapping__Group__1__Impl : ( ( rule__ActorInstanceMapping__PathAssignment_1 ) ) ;
     public final void rule__ActorInstanceMapping__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13366:1: ( ( ( rule__ActorInstanceMapping__PathAssignment_1 ) ) )
-            // InternalRoom.g:13367:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
+            // InternalRoom.g:13595:1: ( ( ( rule__ActorInstanceMapping__PathAssignment_1 ) ) )
+            // InternalRoom.g:13596:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
             {
-            // InternalRoom.g:13367:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
-            // InternalRoom.g:13368:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
+            // InternalRoom.g:13596:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
+            // InternalRoom.g:13597:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
             {
              before(grammarAccess.getActorInstanceMappingAccess().getPathAssignment_1()); 
-            // InternalRoom.g:13369:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
-            // InternalRoom.g:13369:2: rule__ActorInstanceMapping__PathAssignment_1
+            // InternalRoom.g:13598:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
+            // InternalRoom.g:13598:2: rule__ActorInstanceMapping__PathAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__PathAssignment_1();
@@ -37642,14 +38301,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__2"
-    // InternalRoom.g:13379:1: rule__ActorInstanceMapping__Group__2 : rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3 ;
+    // InternalRoom.g:13608:1: rule__ActorInstanceMapping__Group__2 : rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3 ;
     public final void rule__ActorInstanceMapping__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13383:1: ( rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3 )
-            // InternalRoom.g:13384:2: rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3
+            // InternalRoom.g:13612:1: ( rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3 )
+            // InternalRoom.g:13613:2: rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__ActorInstanceMapping__Group__2__Impl();
@@ -37680,17 +38339,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__2__Impl"
-    // InternalRoom.g:13391:1: rule__ActorInstanceMapping__Group__2__Impl : ( '->' ) ;
+    // InternalRoom.g:13620:1: rule__ActorInstanceMapping__Group__2__Impl : ( '->' ) ;
     public final void rule__ActorInstanceMapping__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13395:1: ( ( '->' ) )
-            // InternalRoom.g:13396:1: ( '->' )
+            // InternalRoom.g:13624:1: ( ( '->' ) )
+            // InternalRoom.g:13625:1: ( '->' )
             {
-            // InternalRoom.g:13396:1: ( '->' )
-            // InternalRoom.g:13397:1: '->'
+            // InternalRoom.g:13625:1: ( '->' )
+            // InternalRoom.g:13626:1: '->'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getHyphenMinusGreaterThanSignKeyword_2()); 
             match(input,48,FOLLOW_2); 
@@ -37717,14 +38376,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__3"
-    // InternalRoom.g:13410:1: rule__ActorInstanceMapping__Group__3 : rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4 ;
+    // InternalRoom.g:13639:1: rule__ActorInstanceMapping__Group__3 : rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4 ;
     public final void rule__ActorInstanceMapping__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13414:1: ( rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4 )
-            // InternalRoom.g:13415:2: rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4
+            // InternalRoom.g:13643:1: ( rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4 )
+            // InternalRoom.g:13644:2: rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4
             {
             pushFollow(FOLLOW_40);
             rule__ActorInstanceMapping__Group__3__Impl();
@@ -37755,21 +38414,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__3__Impl"
-    // InternalRoom.g:13422:1: rule__ActorInstanceMapping__Group__3__Impl : ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) ) ;
+    // InternalRoom.g:13651:1: rule__ActorInstanceMapping__Group__3__Impl : ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) ) ;
     public final void rule__ActorInstanceMapping__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13426:1: ( ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) ) )
-            // InternalRoom.g:13427:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
+            // InternalRoom.g:13655:1: ( ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) ) )
+            // InternalRoom.g:13656:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
             {
-            // InternalRoom.g:13427:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
-            // InternalRoom.g:13428:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
+            // InternalRoom.g:13656:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
+            // InternalRoom.g:13657:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
             {
              before(grammarAccess.getActorInstanceMappingAccess().getThreadAssignment_3()); 
-            // InternalRoom.g:13429:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
-            // InternalRoom.g:13429:2: rule__ActorInstanceMapping__ThreadAssignment_3
+            // InternalRoom.g:13658:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
+            // InternalRoom.g:13658:2: rule__ActorInstanceMapping__ThreadAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__ThreadAssignment_3();
@@ -37802,14 +38461,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__4"
-    // InternalRoom.g:13439:1: rule__ActorInstanceMapping__Group__4 : rule__ActorInstanceMapping__Group__4__Impl ;
+    // InternalRoom.g:13668:1: rule__ActorInstanceMapping__Group__4 : rule__ActorInstanceMapping__Group__4__Impl ;
     public final void rule__ActorInstanceMapping__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13443:1: ( rule__ActorInstanceMapping__Group__4__Impl )
-            // InternalRoom.g:13444:2: rule__ActorInstanceMapping__Group__4__Impl
+            // InternalRoom.g:13672:1: ( rule__ActorInstanceMapping__Group__4__Impl )
+            // InternalRoom.g:13673:2: rule__ActorInstanceMapping__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__Group__4__Impl();
@@ -37835,29 +38494,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__4__Impl"
-    // InternalRoom.g:13450:1: rule__ActorInstanceMapping__Group__4__Impl : ( ( rule__ActorInstanceMapping__Group_4__0 )? ) ;
+    // InternalRoom.g:13679:1: rule__ActorInstanceMapping__Group__4__Impl : ( ( rule__ActorInstanceMapping__Group_4__0 )? ) ;
     public final void rule__ActorInstanceMapping__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13454:1: ( ( ( rule__ActorInstanceMapping__Group_4__0 )? ) )
-            // InternalRoom.g:13455:1: ( ( rule__ActorInstanceMapping__Group_4__0 )? )
+            // InternalRoom.g:13683:1: ( ( ( rule__ActorInstanceMapping__Group_4__0 )? ) )
+            // InternalRoom.g:13684:1: ( ( rule__ActorInstanceMapping__Group_4__0 )? )
             {
-            // InternalRoom.g:13455:1: ( ( rule__ActorInstanceMapping__Group_4__0 )? )
-            // InternalRoom.g:13456:1: ( rule__ActorInstanceMapping__Group_4__0 )?
+            // InternalRoom.g:13684:1: ( ( rule__ActorInstanceMapping__Group_4__0 )? )
+            // InternalRoom.g:13685:1: ( rule__ActorInstanceMapping__Group_4__0 )?
             {
              before(grammarAccess.getActorInstanceMappingAccess().getGroup_4()); 
-            // InternalRoom.g:13457:1: ( rule__ActorInstanceMapping__Group_4__0 )?
-            int alt141=2;
-            int LA141_0 = input.LA(1);
+            // InternalRoom.g:13686:1: ( rule__ActorInstanceMapping__Group_4__0 )?
+            int alt144=2;
+            int LA144_0 = input.LA(1);
 
-            if ( (LA141_0==44) ) {
-                alt141=1;
+            if ( (LA144_0==44) ) {
+                alt144=1;
             }
-            switch (alt141) {
+            switch (alt144) {
                 case 1 :
-                    // InternalRoom.g:13457:2: rule__ActorInstanceMapping__Group_4__0
+                    // InternalRoom.g:13686:2: rule__ActorInstanceMapping__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorInstanceMapping__Group_4__0();
@@ -37893,16 +38552,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__0"
-    // InternalRoom.g:13477:1: rule__ActorInstanceMapping__Group_4__0 : rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1 ;
+    // InternalRoom.g:13706:1: rule__ActorInstanceMapping__Group_4__0 : rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1 ;
     public final void rule__ActorInstanceMapping__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13481:1: ( rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1 )
-            // InternalRoom.g:13482:2: rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1
+            // InternalRoom.g:13710:1: ( rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1 )
+            // InternalRoom.g:13711:2: rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1
             {
-            pushFollow(FOLLOW_67);
+            pushFollow(FOLLOW_68);
             rule__ActorInstanceMapping__Group_4__0__Impl();
 
             state._fsp--;
@@ -37931,17 +38590,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__0__Impl"
-    // InternalRoom.g:13489:1: rule__ActorInstanceMapping__Group_4__0__Impl : ( '{' ) ;
+    // InternalRoom.g:13718:1: rule__ActorInstanceMapping__Group_4__0__Impl : ( '{' ) ;
     public final void rule__ActorInstanceMapping__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13493:1: ( ( '{' ) )
-            // InternalRoom.g:13494:1: ( '{' )
+            // InternalRoom.g:13722:1: ( ( '{' ) )
+            // InternalRoom.g:13723:1: ( '{' )
             {
-            // InternalRoom.g:13494:1: ( '{' )
-            // InternalRoom.g:13495:1: '{'
+            // InternalRoom.g:13723:1: ( '{' )
+            // InternalRoom.g:13724:1: '{'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0()); 
             match(input,44,FOLLOW_2); 
@@ -37968,16 +38627,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__1"
-    // InternalRoom.g:13508:1: rule__ActorInstanceMapping__Group_4__1 : rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2 ;
+    // InternalRoom.g:13737:1: rule__ActorInstanceMapping__Group_4__1 : rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2 ;
     public final void rule__ActorInstanceMapping__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13512:1: ( rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2 )
-            // InternalRoom.g:13513:2: rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2
+            // InternalRoom.g:13741:1: ( rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2 )
+            // InternalRoom.g:13742:2: rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2
             {
-            pushFollow(FOLLOW_67);
+            pushFollow(FOLLOW_68);
             rule__ActorInstanceMapping__Group_4__1__Impl();
 
             state._fsp--;
@@ -38006,35 +38665,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__1__Impl"
-    // InternalRoom.g:13520:1: rule__ActorInstanceMapping__Group_4__1__Impl : ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* ) ;
+    // InternalRoom.g:13749:1: rule__ActorInstanceMapping__Group_4__1__Impl : ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* ) ;
     public final void rule__ActorInstanceMapping__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13524:1: ( ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* ) )
-            // InternalRoom.g:13525:1: ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* )
+            // InternalRoom.g:13753:1: ( ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* ) )
+            // InternalRoom.g:13754:1: ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* )
             {
-            // InternalRoom.g:13525:1: ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* )
-            // InternalRoom.g:13526:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
+            // InternalRoom.g:13754:1: ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* )
+            // InternalRoom.g:13755:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsAssignment_4_1()); 
-            // InternalRoom.g:13527:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
-            loop142:
+            // InternalRoom.g:13756:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
+            loop145:
             do {
-                int alt142=2;
-                int LA142_0 = input.LA(1);
+                int alt145=2;
+                int LA145_0 = input.LA(1);
 
-                if ( (LA142_0==83) ) {
-                    alt142=1;
+                if ( (LA145_0==83) ) {
+                    alt145=1;
                 }
 
 
-                switch (alt142) {
+                switch (alt145) {
             	case 1 :
-            	    // InternalRoom.g:13527:2: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1
+            	    // InternalRoom.g:13756:2: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1
             	    {
-            	    pushFollow(FOLLOW_68);
+            	    pushFollow(FOLLOW_69);
             	    rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1();
 
             	    state._fsp--;
@@ -38044,7 +38703,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop142;
+            	    break loop145;
                 }
             } while (true);
 
@@ -38071,14 +38730,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__2"
-    // InternalRoom.g:13537:1: rule__ActorInstanceMapping__Group_4__2 : rule__ActorInstanceMapping__Group_4__2__Impl ;
+    // InternalRoom.g:13766:1: rule__ActorInstanceMapping__Group_4__2 : rule__ActorInstanceMapping__Group_4__2__Impl ;
     public final void rule__ActorInstanceMapping__Group_4__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13541:1: ( rule__ActorInstanceMapping__Group_4__2__Impl )
-            // InternalRoom.g:13542:2: rule__ActorInstanceMapping__Group_4__2__Impl
+            // InternalRoom.g:13770:1: ( rule__ActorInstanceMapping__Group_4__2__Impl )
+            // InternalRoom.g:13771:2: rule__ActorInstanceMapping__Group_4__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__Group_4__2__Impl();
@@ -38104,17 +38763,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group_4__2__Impl"
-    // InternalRoom.g:13548:1: rule__ActorInstanceMapping__Group_4__2__Impl : ( '}' ) ;
+    // InternalRoom.g:13777:1: rule__ActorInstanceMapping__Group_4__2__Impl : ( '}' ) ;
     public final void rule__ActorInstanceMapping__Group_4__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13552:1: ( ( '}' ) )
-            // InternalRoom.g:13553:1: ( '}' )
+            // InternalRoom.g:13781:1: ( ( '}' ) )
+            // InternalRoom.g:13782:1: ( '}' )
             {
-            // InternalRoom.g:13553:1: ( '}' )
-            // InternalRoom.g:13554:1: '}'
+            // InternalRoom.g:13782:1: ( '}' )
+            // InternalRoom.g:13783:1: '}'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getRightCurlyBracketKeyword_4_2()); 
             match(input,45,FOLLOW_2); 
@@ -38141,16 +38800,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group__0"
-    // InternalRoom.g:13573:1: rule__RefPath__Group__0 : rule__RefPath__Group__0__Impl rule__RefPath__Group__1 ;
+    // InternalRoom.g:13802:1: rule__RefPath__Group__0 : rule__RefPath__Group__0__Impl rule__RefPath__Group__1 ;
     public final void rule__RefPath__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13577:1: ( rule__RefPath__Group__0__Impl rule__RefPath__Group__1 )
-            // InternalRoom.g:13578:2: rule__RefPath__Group__0__Impl rule__RefPath__Group__1
+            // InternalRoom.g:13806:1: ( rule__RefPath__Group__0__Impl rule__RefPath__Group__1 )
+            // InternalRoom.g:13807:2: rule__RefPath__Group__0__Impl rule__RefPath__Group__1
             {
-            pushFollow(FOLLOW_69);
+            pushFollow(FOLLOW_70);
             rule__RefPath__Group__0__Impl();
 
             state._fsp--;
@@ -38179,21 +38838,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group__0__Impl"
-    // InternalRoom.g:13585:1: rule__RefPath__Group__0__Impl : ( ( rule__RefPath__RefsAssignment_0 ) ) ;
+    // InternalRoom.g:13814:1: rule__RefPath__Group__0__Impl : ( ( rule__RefPath__RefsAssignment_0 ) ) ;
     public final void rule__RefPath__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13589:1: ( ( ( rule__RefPath__RefsAssignment_0 ) ) )
-            // InternalRoom.g:13590:1: ( ( rule__RefPath__RefsAssignment_0 ) )
+            // InternalRoom.g:13818:1: ( ( ( rule__RefPath__RefsAssignment_0 ) ) )
+            // InternalRoom.g:13819:1: ( ( rule__RefPath__RefsAssignment_0 ) )
             {
-            // InternalRoom.g:13590:1: ( ( rule__RefPath__RefsAssignment_0 ) )
-            // InternalRoom.g:13591:1: ( rule__RefPath__RefsAssignment_0 )
+            // InternalRoom.g:13819:1: ( ( rule__RefPath__RefsAssignment_0 ) )
+            // InternalRoom.g:13820:1: ( rule__RefPath__RefsAssignment_0 )
             {
              before(grammarAccess.getRefPathAccess().getRefsAssignment_0()); 
-            // InternalRoom.g:13592:1: ( rule__RefPath__RefsAssignment_0 )
-            // InternalRoom.g:13592:2: rule__RefPath__RefsAssignment_0
+            // InternalRoom.g:13821:1: ( rule__RefPath__RefsAssignment_0 )
+            // InternalRoom.g:13821:2: rule__RefPath__RefsAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__RefsAssignment_0();
@@ -38226,14 +38885,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group__1"
-    // InternalRoom.g:13602:1: rule__RefPath__Group__1 : rule__RefPath__Group__1__Impl ;
+    // InternalRoom.g:13831:1: rule__RefPath__Group__1 : rule__RefPath__Group__1__Impl ;
     public final void rule__RefPath__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13606:1: ( rule__RefPath__Group__1__Impl )
-            // InternalRoom.g:13607:2: rule__RefPath__Group__1__Impl
+            // InternalRoom.g:13835:1: ( rule__RefPath__Group__1__Impl )
+            // InternalRoom.g:13836:2: rule__RefPath__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__Group__1__Impl();
@@ -38259,35 +38918,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group__1__Impl"
-    // InternalRoom.g:13613:1: rule__RefPath__Group__1__Impl : ( ( rule__RefPath__Group_1__0 )* ) ;
+    // InternalRoom.g:13842:1: rule__RefPath__Group__1__Impl : ( ( rule__RefPath__Group_1__0 )* ) ;
     public final void rule__RefPath__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13617:1: ( ( ( rule__RefPath__Group_1__0 )* ) )
-            // InternalRoom.g:13618:1: ( ( rule__RefPath__Group_1__0 )* )
+            // InternalRoom.g:13846:1: ( ( ( rule__RefPath__Group_1__0 )* ) )
+            // InternalRoom.g:13847:1: ( ( rule__RefPath__Group_1__0 )* )
             {
-            // InternalRoom.g:13618:1: ( ( rule__RefPath__Group_1__0 )* )
-            // InternalRoom.g:13619:1: ( rule__RefPath__Group_1__0 )*
+            // InternalRoom.g:13847:1: ( ( rule__RefPath__Group_1__0 )* )
+            // InternalRoom.g:13848:1: ( rule__RefPath__Group_1__0 )*
             {
              before(grammarAccess.getRefPathAccess().getGroup_1()); 
-            // InternalRoom.g:13620:1: ( rule__RefPath__Group_1__0 )*
-            loop143:
+            // InternalRoom.g:13849:1: ( rule__RefPath__Group_1__0 )*
+            loop146:
             do {
-                int alt143=2;
-                int LA143_0 = input.LA(1);
+                int alt146=2;
+                int LA146_0 = input.LA(1);
 
-                if ( (LA143_0==84) ) {
-                    alt143=1;
+                if ( (LA146_0==84) ) {
+                    alt146=1;
                 }
 
 
-                switch (alt143) {
+                switch (alt146) {
             	case 1 :
-            	    // InternalRoom.g:13620:2: rule__RefPath__Group_1__0
+            	    // InternalRoom.g:13849:2: rule__RefPath__Group_1__0
             	    {
-            	    pushFollow(FOLLOW_70);
+            	    pushFollow(FOLLOW_71);
             	    rule__RefPath__Group_1__0();
 
             	    state._fsp--;
@@ -38297,7 +38956,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop143;
+            	    break loop146;
                 }
             } while (true);
 
@@ -38324,14 +38983,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group_1__0"
-    // InternalRoom.g:13634:1: rule__RefPath__Group_1__0 : rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1 ;
+    // InternalRoom.g:13863:1: rule__RefPath__Group_1__0 : rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1 ;
     public final void rule__RefPath__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13638:1: ( rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1 )
-            // InternalRoom.g:13639:2: rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1
+            // InternalRoom.g:13867:1: ( rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1 )
+            // InternalRoom.g:13868:2: rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1
             {
             pushFollow(FOLLOW_3);
             rule__RefPath__Group_1__0__Impl();
@@ -38362,17 +39021,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group_1__0__Impl"
-    // InternalRoom.g:13646:1: rule__RefPath__Group_1__0__Impl : ( '/' ) ;
+    // InternalRoom.g:13875:1: rule__RefPath__Group_1__0__Impl : ( '/' ) ;
     public final void rule__RefPath__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13650:1: ( ( '/' ) )
-            // InternalRoom.g:13651:1: ( '/' )
+            // InternalRoom.g:13879:1: ( ( '/' ) )
+            // InternalRoom.g:13880:1: ( '/' )
             {
-            // InternalRoom.g:13651:1: ( '/' )
-            // InternalRoom.g:13652:1: '/'
+            // InternalRoom.g:13880:1: ( '/' )
+            // InternalRoom.g:13881:1: '/'
             {
              before(grammarAccess.getRefPathAccess().getSolidusKeyword_1_0()); 
             match(input,84,FOLLOW_2); 
@@ -38399,14 +39058,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group_1__1"
-    // InternalRoom.g:13665:1: rule__RefPath__Group_1__1 : rule__RefPath__Group_1__1__Impl ;
+    // InternalRoom.g:13894:1: rule__RefPath__Group_1__1 : rule__RefPath__Group_1__1__Impl ;
     public final void rule__RefPath__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13669:1: ( rule__RefPath__Group_1__1__Impl )
-            // InternalRoom.g:13670:2: rule__RefPath__Group_1__1__Impl
+            // InternalRoom.g:13898:1: ( rule__RefPath__Group_1__1__Impl )
+            // InternalRoom.g:13899:2: rule__RefPath__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__Group_1__1__Impl();
@@ -38432,21 +39091,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__Group_1__1__Impl"
-    // InternalRoom.g:13676:1: rule__RefPath__Group_1__1__Impl : ( ( rule__RefPath__RefsAssignment_1_1 ) ) ;
+    // InternalRoom.g:13905:1: rule__RefPath__Group_1__1__Impl : ( ( rule__RefPath__RefsAssignment_1_1 ) ) ;
     public final void rule__RefPath__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13680:1: ( ( ( rule__RefPath__RefsAssignment_1_1 ) ) )
-            // InternalRoom.g:13681:1: ( ( rule__RefPath__RefsAssignment_1_1 ) )
+            // InternalRoom.g:13909:1: ( ( ( rule__RefPath__RefsAssignment_1_1 ) ) )
+            // InternalRoom.g:13910:1: ( ( rule__RefPath__RefsAssignment_1_1 ) )
             {
-            // InternalRoom.g:13681:1: ( ( rule__RefPath__RefsAssignment_1_1 ) )
-            // InternalRoom.g:13682:1: ( rule__RefPath__RefsAssignment_1_1 )
+            // InternalRoom.g:13910:1: ( ( rule__RefPath__RefsAssignment_1_1 ) )
+            // InternalRoom.g:13911:1: ( rule__RefPath__RefsAssignment_1_1 )
             {
              before(grammarAccess.getRefPathAccess().getRefsAssignment_1_1()); 
-            // InternalRoom.g:13683:1: ( rule__RefPath__RefsAssignment_1_1 )
-            // InternalRoom.g:13683:2: rule__RefPath__RefsAssignment_1_1
+            // InternalRoom.g:13912:1: ( rule__RefPath__RefsAssignment_1_1 )
+            // InternalRoom.g:13912:2: rule__RefPath__RefsAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__RefsAssignment_1_1();
@@ -38479,14 +39138,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group__0"
-    // InternalRoom.g:13697:1: rule__RefSegment__Group__0 : rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1 ;
+    // InternalRoom.g:13926:1: rule__RefSegment__Group__0 : rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1 ;
     public final void rule__RefSegment__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13701:1: ( rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1 )
-            // InternalRoom.g:13702:2: rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1
+            // InternalRoom.g:13930:1: ( rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1 )
+            // InternalRoom.g:13931:2: rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__RefSegment__Group__0__Impl();
@@ -38517,21 +39176,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group__0__Impl"
-    // InternalRoom.g:13709:1: rule__RefSegment__Group__0__Impl : ( ( rule__RefSegment__RefAssignment_0 ) ) ;
+    // InternalRoom.g:13938:1: rule__RefSegment__Group__0__Impl : ( ( rule__RefSegment__RefAssignment_0 ) ) ;
     public final void rule__RefSegment__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13713:1: ( ( ( rule__RefSegment__RefAssignment_0 ) ) )
-            // InternalRoom.g:13714:1: ( ( rule__RefSegment__RefAssignment_0 ) )
+            // InternalRoom.g:13942:1: ( ( ( rule__RefSegment__RefAssignment_0 ) ) )
+            // InternalRoom.g:13943:1: ( ( rule__RefSegment__RefAssignment_0 ) )
             {
-            // InternalRoom.g:13714:1: ( ( rule__RefSegment__RefAssignment_0 ) )
-            // InternalRoom.g:13715:1: ( rule__RefSegment__RefAssignment_0 )
+            // InternalRoom.g:13943:1: ( ( rule__RefSegment__RefAssignment_0 ) )
+            // InternalRoom.g:13944:1: ( rule__RefSegment__RefAssignment_0 )
             {
              before(grammarAccess.getRefSegmentAccess().getRefAssignment_0()); 
-            // InternalRoom.g:13716:1: ( rule__RefSegment__RefAssignment_0 )
-            // InternalRoom.g:13716:2: rule__RefSegment__RefAssignment_0
+            // InternalRoom.g:13945:1: ( rule__RefSegment__RefAssignment_0 )
+            // InternalRoom.g:13945:2: rule__RefSegment__RefAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__RefAssignment_0();
@@ -38564,14 +39223,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group__1"
-    // InternalRoom.g:13726:1: rule__RefSegment__Group__1 : rule__RefSegment__Group__1__Impl ;
+    // InternalRoom.g:13955:1: rule__RefSegment__Group__1 : rule__RefSegment__Group__1__Impl ;
     public final void rule__RefSegment__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13730:1: ( rule__RefSegment__Group__1__Impl )
-            // InternalRoom.g:13731:2: rule__RefSegment__Group__1__Impl
+            // InternalRoom.g:13959:1: ( rule__RefSegment__Group__1__Impl )
+            // InternalRoom.g:13960:2: rule__RefSegment__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__Group__1__Impl();
@@ -38597,29 +39256,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group__1__Impl"
-    // InternalRoom.g:13737:1: rule__RefSegment__Group__1__Impl : ( ( rule__RefSegment__Group_1__0 )? ) ;
+    // InternalRoom.g:13966:1: rule__RefSegment__Group__1__Impl : ( ( rule__RefSegment__Group_1__0 )? ) ;
     public final void rule__RefSegment__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13741:1: ( ( ( rule__RefSegment__Group_1__0 )? ) )
-            // InternalRoom.g:13742:1: ( ( rule__RefSegment__Group_1__0 )? )
+            // InternalRoom.g:13970:1: ( ( ( rule__RefSegment__Group_1__0 )? ) )
+            // InternalRoom.g:13971:1: ( ( rule__RefSegment__Group_1__0 )? )
             {
-            // InternalRoom.g:13742:1: ( ( rule__RefSegment__Group_1__0 )? )
-            // InternalRoom.g:13743:1: ( rule__RefSegment__Group_1__0 )?
+            // InternalRoom.g:13971:1: ( ( rule__RefSegment__Group_1__0 )? )
+            // InternalRoom.g:13972:1: ( rule__RefSegment__Group_1__0 )?
             {
              before(grammarAccess.getRefSegmentAccess().getGroup_1()); 
-            // InternalRoom.g:13744:1: ( rule__RefSegment__Group_1__0 )?
-            int alt144=2;
-            int LA144_0 = input.LA(1);
+            // InternalRoom.g:13973:1: ( rule__RefSegment__Group_1__0 )?
+            int alt147=2;
+            int LA147_0 = input.LA(1);
 
-            if ( (LA144_0==46) ) {
-                alt144=1;
+            if ( (LA147_0==46) ) {
+                alt147=1;
             }
-            switch (alt144) {
+            switch (alt147) {
                 case 1 :
-                    // InternalRoom.g:13744:2: rule__RefSegment__Group_1__0
+                    // InternalRoom.g:13973:2: rule__RefSegment__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefSegment__Group_1__0();
@@ -38655,14 +39314,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group_1__0"
-    // InternalRoom.g:13758:1: rule__RefSegment__Group_1__0 : rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1 ;
+    // InternalRoom.g:13987:1: rule__RefSegment__Group_1__0 : rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1 ;
     public final void rule__RefSegment__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13762:1: ( rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1 )
-            // InternalRoom.g:13763:2: rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1
+            // InternalRoom.g:13991:1: ( rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1 )
+            // InternalRoom.g:13992:2: rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1
             {
             pushFollow(FOLLOW_30);
             rule__RefSegment__Group_1__0__Impl();
@@ -38693,17 +39352,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group_1__0__Impl"
-    // InternalRoom.g:13770:1: rule__RefSegment__Group_1__0__Impl : ( ':' ) ;
+    // InternalRoom.g:13999:1: rule__RefSegment__Group_1__0__Impl : ( ':' ) ;
     public final void rule__RefSegment__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13774:1: ( ( ':' ) )
-            // InternalRoom.g:13775:1: ( ':' )
+            // InternalRoom.g:14003:1: ( ( ':' ) )
+            // InternalRoom.g:14004:1: ( ':' )
             {
-            // InternalRoom.g:13775:1: ( ':' )
-            // InternalRoom.g:13776:1: ':'
+            // InternalRoom.g:14004:1: ( ':' )
+            // InternalRoom.g:14005:1: ':'
             {
              before(grammarAccess.getRefSegmentAccess().getColonKeyword_1_0()); 
             match(input,46,FOLLOW_2); 
@@ -38730,14 +39389,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group_1__1"
-    // InternalRoom.g:13789:1: rule__RefSegment__Group_1__1 : rule__RefSegment__Group_1__1__Impl ;
+    // InternalRoom.g:14018:1: rule__RefSegment__Group_1__1 : rule__RefSegment__Group_1__1__Impl ;
     public final void rule__RefSegment__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13793:1: ( rule__RefSegment__Group_1__1__Impl )
-            // InternalRoom.g:13794:2: rule__RefSegment__Group_1__1__Impl
+            // InternalRoom.g:14022:1: ( rule__RefSegment__Group_1__1__Impl )
+            // InternalRoom.g:14023:2: rule__RefSegment__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__Group_1__1__Impl();
@@ -38763,21 +39422,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__Group_1__1__Impl"
-    // InternalRoom.g:13800:1: rule__RefSegment__Group_1__1__Impl : ( ( rule__RefSegment__IdxAssignment_1_1 ) ) ;
+    // InternalRoom.g:14029:1: rule__RefSegment__Group_1__1__Impl : ( ( rule__RefSegment__IdxAssignment_1_1 ) ) ;
     public final void rule__RefSegment__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13804:1: ( ( ( rule__RefSegment__IdxAssignment_1_1 ) ) )
-            // InternalRoom.g:13805:1: ( ( rule__RefSegment__IdxAssignment_1_1 ) )
+            // InternalRoom.g:14033:1: ( ( ( rule__RefSegment__IdxAssignment_1_1 ) ) )
+            // InternalRoom.g:14034:1: ( ( rule__RefSegment__IdxAssignment_1_1 ) )
             {
-            // InternalRoom.g:13805:1: ( ( rule__RefSegment__IdxAssignment_1_1 ) )
-            // InternalRoom.g:13806:1: ( rule__RefSegment__IdxAssignment_1_1 )
+            // InternalRoom.g:14034:1: ( ( rule__RefSegment__IdxAssignment_1_1 ) )
+            // InternalRoom.g:14035:1: ( rule__RefSegment__IdxAssignment_1_1 )
             {
              before(grammarAccess.getRefSegmentAccess().getIdxAssignment_1_1()); 
-            // InternalRoom.g:13807:1: ( rule__RefSegment__IdxAssignment_1_1 )
-            // InternalRoom.g:13807:2: rule__RefSegment__IdxAssignment_1_1
+            // InternalRoom.g:14036:1: ( rule__RefSegment__IdxAssignment_1_1 )
+            // InternalRoom.g:14036:2: rule__RefSegment__IdxAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__IdxAssignment_1_1();
@@ -38810,14 +39469,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__0"
-    // InternalRoom.g:13821:1: rule__Binding__Group__0 : rule__Binding__Group__0__Impl rule__Binding__Group__1 ;
+    // InternalRoom.g:14050:1: rule__Binding__Group__0 : rule__Binding__Group__0__Impl rule__Binding__Group__1 ;
     public final void rule__Binding__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13825:1: ( rule__Binding__Group__0__Impl rule__Binding__Group__1 )
-            // InternalRoom.g:13826:2: rule__Binding__Group__0__Impl rule__Binding__Group__1
+            // InternalRoom.g:14054:1: ( rule__Binding__Group__0__Impl rule__Binding__Group__1 )
+            // InternalRoom.g:14055:2: rule__Binding__Group__0__Impl rule__Binding__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Binding__Group__0__Impl();
@@ -38848,17 +39507,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__0__Impl"
-    // InternalRoom.g:13833:1: rule__Binding__Group__0__Impl : ( 'Binding' ) ;
+    // InternalRoom.g:14062:1: rule__Binding__Group__0__Impl : ( 'Binding' ) ;
     public final void rule__Binding__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13837:1: ( ( 'Binding' ) )
-            // InternalRoom.g:13838:1: ( 'Binding' )
+            // InternalRoom.g:14066:1: ( ( 'Binding' ) )
+            // InternalRoom.g:14067:1: ( 'Binding' )
             {
-            // InternalRoom.g:13838:1: ( 'Binding' )
-            // InternalRoom.g:13839:1: 'Binding'
+            // InternalRoom.g:14067:1: ( 'Binding' )
+            // InternalRoom.g:14068:1: 'Binding'
             {
              before(grammarAccess.getBindingAccess().getBindingKeyword_0()); 
             match(input,85,FOLLOW_2); 
@@ -38885,16 +39544,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__1"
-    // InternalRoom.g:13852:1: rule__Binding__Group__1 : rule__Binding__Group__1__Impl rule__Binding__Group__2 ;
+    // InternalRoom.g:14081:1: rule__Binding__Group__1 : rule__Binding__Group__1__Impl rule__Binding__Group__2 ;
     public final void rule__Binding__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13856:1: ( rule__Binding__Group__1__Impl rule__Binding__Group__2 )
-            // InternalRoom.g:13857:2: rule__Binding__Group__1__Impl rule__Binding__Group__2
+            // InternalRoom.g:14085:1: ( rule__Binding__Group__1__Impl rule__Binding__Group__2 )
+            // InternalRoom.g:14086:2: rule__Binding__Group__1__Impl rule__Binding__Group__2
             {
-            pushFollow(FOLLOW_71);
+            pushFollow(FOLLOW_72);
             rule__Binding__Group__1__Impl();
 
             state._fsp--;
@@ -38923,21 +39582,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__1__Impl"
-    // InternalRoom.g:13864:1: rule__Binding__Group__1__Impl : ( ( rule__Binding__Endpoint1Assignment_1 ) ) ;
+    // InternalRoom.g:14093:1: rule__Binding__Group__1__Impl : ( ( rule__Binding__Endpoint1Assignment_1 ) ) ;
     public final void rule__Binding__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13868:1: ( ( ( rule__Binding__Endpoint1Assignment_1 ) ) )
-            // InternalRoom.g:13869:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
+            // InternalRoom.g:14097:1: ( ( ( rule__Binding__Endpoint1Assignment_1 ) ) )
+            // InternalRoom.g:14098:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
             {
-            // InternalRoom.g:13869:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
-            // InternalRoom.g:13870:1: ( rule__Binding__Endpoint1Assignment_1 )
+            // InternalRoom.g:14098:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
+            // InternalRoom.g:14099:1: ( rule__Binding__Endpoint1Assignment_1 )
             {
              before(grammarAccess.getBindingAccess().getEndpoint1Assignment_1()); 
-            // InternalRoom.g:13871:1: ( rule__Binding__Endpoint1Assignment_1 )
-            // InternalRoom.g:13871:2: rule__Binding__Endpoint1Assignment_1
+            // InternalRoom.g:14100:1: ( rule__Binding__Endpoint1Assignment_1 )
+            // InternalRoom.g:14100:2: rule__Binding__Endpoint1Assignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Endpoint1Assignment_1();
@@ -38970,14 +39629,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__2"
-    // InternalRoom.g:13881:1: rule__Binding__Group__2 : rule__Binding__Group__2__Impl rule__Binding__Group__3 ;
+    // InternalRoom.g:14110:1: rule__Binding__Group__2 : rule__Binding__Group__2__Impl rule__Binding__Group__3 ;
     public final void rule__Binding__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13885:1: ( rule__Binding__Group__2__Impl rule__Binding__Group__3 )
-            // InternalRoom.g:13886:2: rule__Binding__Group__2__Impl rule__Binding__Group__3
+            // InternalRoom.g:14114:1: ( rule__Binding__Group__2__Impl rule__Binding__Group__3 )
+            // InternalRoom.g:14115:2: rule__Binding__Group__2__Impl rule__Binding__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__Binding__Group__2__Impl();
@@ -39008,17 +39667,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__2__Impl"
-    // InternalRoom.g:13893:1: rule__Binding__Group__2__Impl : ( 'and' ) ;
+    // InternalRoom.g:14122:1: rule__Binding__Group__2__Impl : ( 'and' ) ;
     public final void rule__Binding__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13897:1: ( ( 'and' ) )
-            // InternalRoom.g:13898:1: ( 'and' )
+            // InternalRoom.g:14126:1: ( ( 'and' ) )
+            // InternalRoom.g:14127:1: ( 'and' )
             {
-            // InternalRoom.g:13898:1: ( 'and' )
-            // InternalRoom.g:13899:1: 'and'
+            // InternalRoom.g:14127:1: ( 'and' )
+            // InternalRoom.g:14128:1: 'and'
             {
              before(grammarAccess.getBindingAccess().getAndKeyword_2()); 
             match(input,86,FOLLOW_2); 
@@ -39045,14 +39704,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__3"
-    // InternalRoom.g:13912:1: rule__Binding__Group__3 : rule__Binding__Group__3__Impl ;
+    // InternalRoom.g:14141:1: rule__Binding__Group__3 : rule__Binding__Group__3__Impl ;
     public final void rule__Binding__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13916:1: ( rule__Binding__Group__3__Impl )
-            // InternalRoom.g:13917:2: rule__Binding__Group__3__Impl
+            // InternalRoom.g:14145:1: ( rule__Binding__Group__3__Impl )
+            // InternalRoom.g:14146:2: rule__Binding__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Group__3__Impl();
@@ -39078,21 +39737,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Group__3__Impl"
-    // InternalRoom.g:13923:1: rule__Binding__Group__3__Impl : ( ( rule__Binding__Endpoint2Assignment_3 ) ) ;
+    // InternalRoom.g:14152:1: rule__Binding__Group__3__Impl : ( ( rule__Binding__Endpoint2Assignment_3 ) ) ;
     public final void rule__Binding__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13927:1: ( ( ( rule__Binding__Endpoint2Assignment_3 ) ) )
-            // InternalRoom.g:13928:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
+            // InternalRoom.g:14156:1: ( ( ( rule__Binding__Endpoint2Assignment_3 ) ) )
+            // InternalRoom.g:14157:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
             {
-            // InternalRoom.g:13928:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
-            // InternalRoom.g:13929:1: ( rule__Binding__Endpoint2Assignment_3 )
+            // InternalRoom.g:14157:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
+            // InternalRoom.g:14158:1: ( rule__Binding__Endpoint2Assignment_3 )
             {
              before(grammarAccess.getBindingAccess().getEndpoint2Assignment_3()); 
-            // InternalRoom.g:13930:1: ( rule__Binding__Endpoint2Assignment_3 )
-            // InternalRoom.g:13930:2: rule__Binding__Endpoint2Assignment_3
+            // InternalRoom.g:14159:1: ( rule__Binding__Endpoint2Assignment_3 )
+            // InternalRoom.g:14159:2: rule__Binding__Endpoint2Assignment_3
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Endpoint2Assignment_3();
@@ -39125,14 +39784,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__0"
-    // InternalRoom.g:13948:1: rule__BindingEndPoint__Group__0 : rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1 ;
+    // InternalRoom.g:14177:1: rule__BindingEndPoint__Group__0 : rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1 ;
     public final void rule__BindingEndPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13952:1: ( rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1 )
-            // InternalRoom.g:13953:2: rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1
+            // InternalRoom.g:14181:1: ( rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1 )
+            // InternalRoom.g:14182:2: rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__BindingEndPoint__Group__0__Impl();
@@ -39163,33 +39822,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__0__Impl"
-    // InternalRoom.g:13960:1: rule__BindingEndPoint__Group__0__Impl : ( ( rule__BindingEndPoint__Group_0__0 )? ) ;
+    // InternalRoom.g:14189:1: rule__BindingEndPoint__Group__0__Impl : ( ( rule__BindingEndPoint__Group_0__0 )? ) ;
     public final void rule__BindingEndPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13964:1: ( ( ( rule__BindingEndPoint__Group_0__0 )? ) )
-            // InternalRoom.g:13965:1: ( ( rule__BindingEndPoint__Group_0__0 )? )
+            // InternalRoom.g:14193:1: ( ( ( rule__BindingEndPoint__Group_0__0 )? ) )
+            // InternalRoom.g:14194:1: ( ( rule__BindingEndPoint__Group_0__0 )? )
             {
-            // InternalRoom.g:13965:1: ( ( rule__BindingEndPoint__Group_0__0 )? )
-            // InternalRoom.g:13966:1: ( rule__BindingEndPoint__Group_0__0 )?
+            // InternalRoom.g:14194:1: ( ( rule__BindingEndPoint__Group_0__0 )? )
+            // InternalRoom.g:14195:1: ( rule__BindingEndPoint__Group_0__0 )?
             {
              before(grammarAccess.getBindingEndPointAccess().getGroup_0()); 
-            // InternalRoom.g:13967:1: ( rule__BindingEndPoint__Group_0__0 )?
-            int alt145=2;
-            int LA145_0 = input.LA(1);
+            // InternalRoom.g:14196:1: ( rule__BindingEndPoint__Group_0__0 )?
+            int alt148=2;
+            int LA148_0 = input.LA(1);
 
-            if ( (LA145_0==RULE_ID) ) {
-                int LA145_1 = input.LA(2);
+            if ( (LA148_0==RULE_ID) ) {
+                int LA148_1 = input.LA(2);
 
-                if ( (LA145_1==87) ) {
-                    alt145=1;
+                if ( (LA148_1==87) ) {
+                    alt148=1;
                 }
             }
-            switch (alt145) {
+            switch (alt148) {
                 case 1 :
-                    // InternalRoom.g:13967:2: rule__BindingEndPoint__Group_0__0
+                    // InternalRoom.g:14196:2: rule__BindingEndPoint__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__BindingEndPoint__Group_0__0();
@@ -39225,16 +39884,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__1"
-    // InternalRoom.g:13977:1: rule__BindingEndPoint__Group__1 : rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2 ;
+    // InternalRoom.g:14206:1: rule__BindingEndPoint__Group__1 : rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2 ;
     public final void rule__BindingEndPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13981:1: ( rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2 )
-            // InternalRoom.g:13982:2: rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2
+            // InternalRoom.g:14210:1: ( rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2 )
+            // InternalRoom.g:14211:2: rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2
             {
-            pushFollow(FOLLOW_72);
+            pushFollow(FOLLOW_73);
             rule__BindingEndPoint__Group__1__Impl();
 
             state._fsp--;
@@ -39263,21 +39922,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__1__Impl"
-    // InternalRoom.g:13989:1: rule__BindingEndPoint__Group__1__Impl : ( ( rule__BindingEndPoint__PortAssignment_1 ) ) ;
+    // InternalRoom.g:14218:1: rule__BindingEndPoint__Group__1__Impl : ( ( rule__BindingEndPoint__PortAssignment_1 ) ) ;
     public final void rule__BindingEndPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:13993:1: ( ( ( rule__BindingEndPoint__PortAssignment_1 ) ) )
-            // InternalRoom.g:13994:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
+            // InternalRoom.g:14222:1: ( ( ( rule__BindingEndPoint__PortAssignment_1 ) ) )
+            // InternalRoom.g:14223:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
             {
-            // InternalRoom.g:13994:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
-            // InternalRoom.g:13995:1: ( rule__BindingEndPoint__PortAssignment_1 )
+            // InternalRoom.g:14223:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
+            // InternalRoom.g:14224:1: ( rule__BindingEndPoint__PortAssignment_1 )
             {
              before(grammarAccess.getBindingEndPointAccess().getPortAssignment_1()); 
-            // InternalRoom.g:13996:1: ( rule__BindingEndPoint__PortAssignment_1 )
-            // InternalRoom.g:13996:2: rule__BindingEndPoint__PortAssignment_1
+            // InternalRoom.g:14225:1: ( rule__BindingEndPoint__PortAssignment_1 )
+            // InternalRoom.g:14225:2: rule__BindingEndPoint__PortAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__PortAssignment_1();
@@ -39310,14 +39969,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__2"
-    // InternalRoom.g:14006:1: rule__BindingEndPoint__Group__2 : rule__BindingEndPoint__Group__2__Impl ;
+    // InternalRoom.g:14235:1: rule__BindingEndPoint__Group__2 : rule__BindingEndPoint__Group__2__Impl ;
     public final void rule__BindingEndPoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14010:1: ( rule__BindingEndPoint__Group__2__Impl )
-            // InternalRoom.g:14011:2: rule__BindingEndPoint__Group__2__Impl
+            // InternalRoom.g:14239:1: ( rule__BindingEndPoint__Group__2__Impl )
+            // InternalRoom.g:14240:2: rule__BindingEndPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group__2__Impl();
@@ -39343,29 +40002,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group__2__Impl"
-    // InternalRoom.g:14017:1: rule__BindingEndPoint__Group__2__Impl : ( ( rule__BindingEndPoint__Group_2__0 )? ) ;
+    // InternalRoom.g:14246:1: rule__BindingEndPoint__Group__2__Impl : ( ( rule__BindingEndPoint__Group_2__0 )? ) ;
     public final void rule__BindingEndPoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14021:1: ( ( ( rule__BindingEndPoint__Group_2__0 )? ) )
-            // InternalRoom.g:14022:1: ( ( rule__BindingEndPoint__Group_2__0 )? )
+            // InternalRoom.g:14250:1: ( ( ( rule__BindingEndPoint__Group_2__0 )? ) )
+            // InternalRoom.g:14251:1: ( ( rule__BindingEndPoint__Group_2__0 )? )
             {
-            // InternalRoom.g:14022:1: ( ( rule__BindingEndPoint__Group_2__0 )? )
-            // InternalRoom.g:14023:1: ( rule__BindingEndPoint__Group_2__0 )?
+            // InternalRoom.g:14251:1: ( ( rule__BindingEndPoint__Group_2__0 )? )
+            // InternalRoom.g:14252:1: ( rule__BindingEndPoint__Group_2__0 )?
             {
              before(grammarAccess.getBindingEndPointAccess().getGroup_2()); 
-            // InternalRoom.g:14024:1: ( rule__BindingEndPoint__Group_2__0 )?
-            int alt146=2;
-            int LA146_0 = input.LA(1);
+            // InternalRoom.g:14253:1: ( rule__BindingEndPoint__Group_2__0 )?
+            int alt149=2;
+            int LA149_0 = input.LA(1);
 
-            if ( (LA146_0==88) ) {
-                alt146=1;
+            if ( (LA149_0==88) ) {
+                alt149=1;
             }
-            switch (alt146) {
+            switch (alt149) {
                 case 1 :
-                    // InternalRoom.g:14024:2: rule__BindingEndPoint__Group_2__0
+                    // InternalRoom.g:14253:2: rule__BindingEndPoint__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__BindingEndPoint__Group_2__0();
@@ -39401,16 +40060,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_0__0"
-    // InternalRoom.g:14040:1: rule__BindingEndPoint__Group_0__0 : rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1 ;
+    // InternalRoom.g:14269:1: rule__BindingEndPoint__Group_0__0 : rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1 ;
     public final void rule__BindingEndPoint__Group_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14044:1: ( rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1 )
-            // InternalRoom.g:14045:2: rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1
+            // InternalRoom.g:14273:1: ( rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1 )
+            // InternalRoom.g:14274:2: rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1
             {
-            pushFollow(FOLLOW_73);
+            pushFollow(FOLLOW_74);
             rule__BindingEndPoint__Group_0__0__Impl();
 
             state._fsp--;
@@ -39439,21 +40098,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_0__0__Impl"
-    // InternalRoom.g:14052:1: rule__BindingEndPoint__Group_0__0__Impl : ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) ) ;
+    // InternalRoom.g:14281:1: rule__BindingEndPoint__Group_0__0__Impl : ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) ) ;
     public final void rule__BindingEndPoint__Group_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14056:1: ( ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) ) )
-            // InternalRoom.g:14057:1: ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) )
+            // InternalRoom.g:14285:1: ( ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) ) )
+            // InternalRoom.g:14286:1: ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) )
             {
-            // InternalRoom.g:14057:1: ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) )
-            // InternalRoom.g:14058:1: ( rule__BindingEndPoint__ActorRefAssignment_0_0 )
+            // InternalRoom.g:14286:1: ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) )
+            // InternalRoom.g:14287:1: ( rule__BindingEndPoint__ActorRefAssignment_0_0 )
             {
              before(grammarAccess.getBindingEndPointAccess().getActorRefAssignment_0_0()); 
-            // InternalRoom.g:14059:1: ( rule__BindingEndPoint__ActorRefAssignment_0_0 )
-            // InternalRoom.g:14059:2: rule__BindingEndPoint__ActorRefAssignment_0_0
+            // InternalRoom.g:14288:1: ( rule__BindingEndPoint__ActorRefAssignment_0_0 )
+            // InternalRoom.g:14288:2: rule__BindingEndPoint__ActorRefAssignment_0_0
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__ActorRefAssignment_0_0();
@@ -39486,14 +40145,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_0__1"
-    // InternalRoom.g:14069:1: rule__BindingEndPoint__Group_0__1 : rule__BindingEndPoint__Group_0__1__Impl ;
+    // InternalRoom.g:14298:1: rule__BindingEndPoint__Group_0__1 : rule__BindingEndPoint__Group_0__1__Impl ;
     public final void rule__BindingEndPoint__Group_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14073:1: ( rule__BindingEndPoint__Group_0__1__Impl )
-            // InternalRoom.g:14074:2: rule__BindingEndPoint__Group_0__1__Impl
+            // InternalRoom.g:14302:1: ( rule__BindingEndPoint__Group_0__1__Impl )
+            // InternalRoom.g:14303:2: rule__BindingEndPoint__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group_0__1__Impl();
@@ -39519,17 +40178,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_0__1__Impl"
-    // InternalRoom.g:14080:1: rule__BindingEndPoint__Group_0__1__Impl : ( '.' ) ;
+    // InternalRoom.g:14309:1: rule__BindingEndPoint__Group_0__1__Impl : ( '.' ) ;
     public final void rule__BindingEndPoint__Group_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14084:1: ( ( '.' ) )
-            // InternalRoom.g:14085:1: ( '.' )
+            // InternalRoom.g:14313:1: ( ( '.' ) )
+            // InternalRoom.g:14314:1: ( '.' )
             {
-            // InternalRoom.g:14085:1: ( '.' )
-            // InternalRoom.g:14086:1: '.'
+            // InternalRoom.g:14314:1: ( '.' )
+            // InternalRoom.g:14315:1: '.'
             {
              before(grammarAccess.getBindingEndPointAccess().getFullStopKeyword_0_1()); 
             match(input,87,FOLLOW_2); 
@@ -39556,14 +40215,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_2__0"
-    // InternalRoom.g:14103:1: rule__BindingEndPoint__Group_2__0 : rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1 ;
+    // InternalRoom.g:14332:1: rule__BindingEndPoint__Group_2__0 : rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1 ;
     public final void rule__BindingEndPoint__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14107:1: ( rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1 )
-            // InternalRoom.g:14108:2: rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1
+            // InternalRoom.g:14336:1: ( rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1 )
+            // InternalRoom.g:14337:2: rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__BindingEndPoint__Group_2__0__Impl();
@@ -39594,17 +40253,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_2__0__Impl"
-    // InternalRoom.g:14115:1: rule__BindingEndPoint__Group_2__0__Impl : ( 'sub' ) ;
+    // InternalRoom.g:14344:1: rule__BindingEndPoint__Group_2__0__Impl : ( 'sub' ) ;
     public final void rule__BindingEndPoint__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14119:1: ( ( 'sub' ) )
-            // InternalRoom.g:14120:1: ( 'sub' )
+            // InternalRoom.g:14348:1: ( ( 'sub' ) )
+            // InternalRoom.g:14349:1: ( 'sub' )
             {
-            // InternalRoom.g:14120:1: ( 'sub' )
-            // InternalRoom.g:14121:1: 'sub'
+            // InternalRoom.g:14349:1: ( 'sub' )
+            // InternalRoom.g:14350:1: 'sub'
             {
              before(grammarAccess.getBindingEndPointAccess().getSubKeyword_2_0()); 
             match(input,88,FOLLOW_2); 
@@ -39631,14 +40290,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_2__1"
-    // InternalRoom.g:14134:1: rule__BindingEndPoint__Group_2__1 : rule__BindingEndPoint__Group_2__1__Impl ;
+    // InternalRoom.g:14363:1: rule__BindingEndPoint__Group_2__1 : rule__BindingEndPoint__Group_2__1__Impl ;
     public final void rule__BindingEndPoint__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14138:1: ( rule__BindingEndPoint__Group_2__1__Impl )
-            // InternalRoom.g:14139:2: rule__BindingEndPoint__Group_2__1__Impl
+            // InternalRoom.g:14367:1: ( rule__BindingEndPoint__Group_2__1__Impl )
+            // InternalRoom.g:14368:2: rule__BindingEndPoint__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group_2__1__Impl();
@@ -39664,21 +40323,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__Group_2__1__Impl"
-    // InternalRoom.g:14145:1: rule__BindingEndPoint__Group_2__1__Impl : ( ( rule__BindingEndPoint__SubAssignment_2_1 ) ) ;
+    // InternalRoom.g:14374:1: rule__BindingEndPoint__Group_2__1__Impl : ( ( rule__BindingEndPoint__SubAssignment_2_1 ) ) ;
     public final void rule__BindingEndPoint__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14149:1: ( ( ( rule__BindingEndPoint__SubAssignment_2_1 ) ) )
-            // InternalRoom.g:14150:1: ( ( rule__BindingEndPoint__SubAssignment_2_1 ) )
+            // InternalRoom.g:14378:1: ( ( ( rule__BindingEndPoint__SubAssignment_2_1 ) ) )
+            // InternalRoom.g:14379:1: ( ( rule__BindingEndPoint__SubAssignment_2_1 ) )
             {
-            // InternalRoom.g:14150:1: ( ( rule__BindingEndPoint__SubAssignment_2_1 ) )
-            // InternalRoom.g:14151:1: ( rule__BindingEndPoint__SubAssignment_2_1 )
+            // InternalRoom.g:14379:1: ( ( rule__BindingEndPoint__SubAssignment_2_1 ) )
+            // InternalRoom.g:14380:1: ( rule__BindingEndPoint__SubAssignment_2_1 )
             {
              before(grammarAccess.getBindingEndPointAccess().getSubAssignment_2_1()); 
-            // InternalRoom.g:14152:1: ( rule__BindingEndPoint__SubAssignment_2_1 )
-            // InternalRoom.g:14152:2: rule__BindingEndPoint__SubAssignment_2_1
+            // InternalRoom.g:14381:1: ( rule__BindingEndPoint__SubAssignment_2_1 )
+            // InternalRoom.g:14381:2: rule__BindingEndPoint__SubAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__SubAssignment_2_1();
@@ -39711,16 +40370,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__0"
-    // InternalRoom.g:14166:1: rule__LayerConnection__Group__0 : rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1 ;
+    // InternalRoom.g:14395:1: rule__LayerConnection__Group__0 : rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1 ;
     public final void rule__LayerConnection__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14170:1: ( rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1 )
-            // InternalRoom.g:14171:2: rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1
+            // InternalRoom.g:14399:1: ( rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1 )
+            // InternalRoom.g:14400:2: rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1
             {
-            pushFollow(FOLLOW_74);
+            pushFollow(FOLLOW_75);
             rule__LayerConnection__Group__0__Impl();
 
             state._fsp--;
@@ -39749,17 +40408,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__0__Impl"
-    // InternalRoom.g:14178:1: rule__LayerConnection__Group__0__Impl : ( 'LayerConnection' ) ;
+    // InternalRoom.g:14407:1: rule__LayerConnection__Group__0__Impl : ( 'LayerConnection' ) ;
     public final void rule__LayerConnection__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14182:1: ( ( 'LayerConnection' ) )
-            // InternalRoom.g:14183:1: ( 'LayerConnection' )
+            // InternalRoom.g:14411:1: ( ( 'LayerConnection' ) )
+            // InternalRoom.g:14412:1: ( 'LayerConnection' )
             {
-            // InternalRoom.g:14183:1: ( 'LayerConnection' )
-            // InternalRoom.g:14184:1: 'LayerConnection'
+            // InternalRoom.g:14412:1: ( 'LayerConnection' )
+            // InternalRoom.g:14413:1: 'LayerConnection'
             {
              before(grammarAccess.getLayerConnectionAccess().getLayerConnectionKeyword_0()); 
             match(input,89,FOLLOW_2); 
@@ -39786,16 +40445,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__1"
-    // InternalRoom.g:14197:1: rule__LayerConnection__Group__1 : rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2 ;
+    // InternalRoom.g:14426:1: rule__LayerConnection__Group__1 : rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2 ;
     public final void rule__LayerConnection__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14201:1: ( rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2 )
-            // InternalRoom.g:14202:2: rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2
+            // InternalRoom.g:14430:1: ( rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2 )
+            // InternalRoom.g:14431:2: rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2
             {
-            pushFollow(FOLLOW_75);
+            pushFollow(FOLLOW_76);
             rule__LayerConnection__Group__1__Impl();
 
             state._fsp--;
@@ -39824,21 +40483,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__1__Impl"
-    // InternalRoom.g:14209:1: rule__LayerConnection__Group__1__Impl : ( ( rule__LayerConnection__FromAssignment_1 ) ) ;
+    // InternalRoom.g:14438:1: rule__LayerConnection__Group__1__Impl : ( ( rule__LayerConnection__FromAssignment_1 ) ) ;
     public final void rule__LayerConnection__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14213:1: ( ( ( rule__LayerConnection__FromAssignment_1 ) ) )
-            // InternalRoom.g:14214:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
+            // InternalRoom.g:14442:1: ( ( ( rule__LayerConnection__FromAssignment_1 ) ) )
+            // InternalRoom.g:14443:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
             {
-            // InternalRoom.g:14214:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
-            // InternalRoom.g:14215:1: ( rule__LayerConnection__FromAssignment_1 )
+            // InternalRoom.g:14443:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
+            // InternalRoom.g:14444:1: ( rule__LayerConnection__FromAssignment_1 )
             {
              before(grammarAccess.getLayerConnectionAccess().getFromAssignment_1()); 
-            // InternalRoom.g:14216:1: ( rule__LayerConnection__FromAssignment_1 )
-            // InternalRoom.g:14216:2: rule__LayerConnection__FromAssignment_1
+            // InternalRoom.g:14445:1: ( rule__LayerConnection__FromAssignment_1 )
+            // InternalRoom.g:14445:2: rule__LayerConnection__FromAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__FromAssignment_1();
@@ -39871,14 +40530,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__2"
-    // InternalRoom.g:14226:1: rule__LayerConnection__Group__2 : rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3 ;
+    // InternalRoom.g:14455:1: rule__LayerConnection__Group__2 : rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3 ;
     public final void rule__LayerConnection__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14230:1: ( rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3 )
-            // InternalRoom.g:14231:2: rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3
+            // InternalRoom.g:14459:1: ( rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3 )
+            // InternalRoom.g:14460:2: rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__LayerConnection__Group__2__Impl();
@@ -39909,17 +40568,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__2__Impl"
-    // InternalRoom.g:14238:1: rule__LayerConnection__Group__2__Impl : ( 'satisfied_by' ) ;
+    // InternalRoom.g:14467:1: rule__LayerConnection__Group__2__Impl : ( 'satisfied_by' ) ;
     public final void rule__LayerConnection__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14242:1: ( ( 'satisfied_by' ) )
-            // InternalRoom.g:14243:1: ( 'satisfied_by' )
+            // InternalRoom.g:14471:1: ( ( 'satisfied_by' ) )
+            // InternalRoom.g:14472:1: ( 'satisfied_by' )
             {
-            // InternalRoom.g:14243:1: ( 'satisfied_by' )
-            // InternalRoom.g:14244:1: 'satisfied_by'
+            // InternalRoom.g:14472:1: ( 'satisfied_by' )
+            // InternalRoom.g:14473:1: 'satisfied_by'
             {
              before(grammarAccess.getLayerConnectionAccess().getSatisfied_byKeyword_2()); 
             match(input,90,FOLLOW_2); 
@@ -39946,14 +40605,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__3"
-    // InternalRoom.g:14257:1: rule__LayerConnection__Group__3 : rule__LayerConnection__Group__3__Impl ;
+    // InternalRoom.g:14486:1: rule__LayerConnection__Group__3 : rule__LayerConnection__Group__3__Impl ;
     public final void rule__LayerConnection__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14261:1: ( rule__LayerConnection__Group__3__Impl )
-            // InternalRoom.g:14262:2: rule__LayerConnection__Group__3__Impl
+            // InternalRoom.g:14490:1: ( rule__LayerConnection__Group__3__Impl )
+            // InternalRoom.g:14491:2: rule__LayerConnection__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__Group__3__Impl();
@@ -39979,21 +40638,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__Group__3__Impl"
-    // InternalRoom.g:14268:1: rule__LayerConnection__Group__3__Impl : ( ( rule__LayerConnection__ToAssignment_3 ) ) ;
+    // InternalRoom.g:14497:1: rule__LayerConnection__Group__3__Impl : ( ( rule__LayerConnection__ToAssignment_3 ) ) ;
     public final void rule__LayerConnection__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14272:1: ( ( ( rule__LayerConnection__ToAssignment_3 ) ) )
-            // InternalRoom.g:14273:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
+            // InternalRoom.g:14501:1: ( ( ( rule__LayerConnection__ToAssignment_3 ) ) )
+            // InternalRoom.g:14502:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
             {
-            // InternalRoom.g:14273:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
-            // InternalRoom.g:14274:1: ( rule__LayerConnection__ToAssignment_3 )
+            // InternalRoom.g:14502:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
+            // InternalRoom.g:14503:1: ( rule__LayerConnection__ToAssignment_3 )
             {
              before(grammarAccess.getLayerConnectionAccess().getToAssignment_3()); 
-            // InternalRoom.g:14275:1: ( rule__LayerConnection__ToAssignment_3 )
-            // InternalRoom.g:14275:2: rule__LayerConnection__ToAssignment_3
+            // InternalRoom.g:14504:1: ( rule__LayerConnection__ToAssignment_3 )
+            // InternalRoom.g:14504:2: rule__LayerConnection__ToAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__ToAssignment_3();
@@ -40026,14 +40685,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__Group__0"
-    // InternalRoom.g:14293:1: rule__RefSAPoint__Group__0 : rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1 ;
+    // InternalRoom.g:14522:1: rule__RefSAPoint__Group__0 : rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1 ;
     public final void rule__RefSAPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14297:1: ( rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1 )
-            // InternalRoom.g:14298:2: rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1
+            // InternalRoom.g:14526:1: ( rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1 )
+            // InternalRoom.g:14527:2: rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefSAPoint__Group__0__Impl();
@@ -40064,17 +40723,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__Group__0__Impl"
-    // InternalRoom.g:14305:1: rule__RefSAPoint__Group__0__Impl : ( 'ref' ) ;
+    // InternalRoom.g:14534:1: rule__RefSAPoint__Group__0__Impl : ( 'ref' ) ;
     public final void rule__RefSAPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14309:1: ( ( 'ref' ) )
-            // InternalRoom.g:14310:1: ( 'ref' )
+            // InternalRoom.g:14538:1: ( ( 'ref' ) )
+            // InternalRoom.g:14539:1: ( 'ref' )
             {
-            // InternalRoom.g:14310:1: ( 'ref' )
-            // InternalRoom.g:14311:1: 'ref'
+            // InternalRoom.g:14539:1: ( 'ref' )
+            // InternalRoom.g:14540:1: 'ref'
             {
              before(grammarAccess.getRefSAPointAccess().getRefKeyword_0()); 
             match(input,91,FOLLOW_2); 
@@ -40101,14 +40760,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__Group__1"
-    // InternalRoom.g:14324:1: rule__RefSAPoint__Group__1 : rule__RefSAPoint__Group__1__Impl ;
+    // InternalRoom.g:14553:1: rule__RefSAPoint__Group__1 : rule__RefSAPoint__Group__1__Impl ;
     public final void rule__RefSAPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14328:1: ( rule__RefSAPoint__Group__1__Impl )
-            // InternalRoom.g:14329:2: rule__RefSAPoint__Group__1__Impl
+            // InternalRoom.g:14557:1: ( rule__RefSAPoint__Group__1__Impl )
+            // InternalRoom.g:14558:2: rule__RefSAPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSAPoint__Group__1__Impl();
@@ -40134,21 +40793,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__Group__1__Impl"
-    // InternalRoom.g:14335:1: rule__RefSAPoint__Group__1__Impl : ( ( rule__RefSAPoint__RefAssignment_1 ) ) ;
+    // InternalRoom.g:14564:1: rule__RefSAPoint__Group__1__Impl : ( ( rule__RefSAPoint__RefAssignment_1 ) ) ;
     public final void rule__RefSAPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14339:1: ( ( ( rule__RefSAPoint__RefAssignment_1 ) ) )
-            // InternalRoom.g:14340:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
+            // InternalRoom.g:14568:1: ( ( ( rule__RefSAPoint__RefAssignment_1 ) ) )
+            // InternalRoom.g:14569:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
             {
-            // InternalRoom.g:14340:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
-            // InternalRoom.g:14341:1: ( rule__RefSAPoint__RefAssignment_1 )
+            // InternalRoom.g:14569:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
+            // InternalRoom.g:14570:1: ( rule__RefSAPoint__RefAssignment_1 )
             {
              before(grammarAccess.getRefSAPointAccess().getRefAssignment_1()); 
-            // InternalRoom.g:14342:1: ( rule__RefSAPoint__RefAssignment_1 )
-            // InternalRoom.g:14342:2: rule__RefSAPoint__RefAssignment_1
+            // InternalRoom.g:14571:1: ( rule__RefSAPoint__RefAssignment_1 )
+            // InternalRoom.g:14571:2: rule__RefSAPoint__RefAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefSAPoint__RefAssignment_1();
@@ -40181,14 +40840,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__Group__0"
-    // InternalRoom.g:14356:1: rule__RelaySAPoint__Group__0 : rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1 ;
+    // InternalRoom.g:14585:1: rule__RelaySAPoint__Group__0 : rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1 ;
     public final void rule__RelaySAPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14360:1: ( rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1 )
-            // InternalRoom.g:14361:2: rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1
+            // InternalRoom.g:14589:1: ( rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1 )
+            // InternalRoom.g:14590:2: rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RelaySAPoint__Group__0__Impl();
@@ -40219,17 +40878,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__Group__0__Impl"
-    // InternalRoom.g:14368:1: rule__RelaySAPoint__Group__0__Impl : ( 'relay_sap' ) ;
+    // InternalRoom.g:14597:1: rule__RelaySAPoint__Group__0__Impl : ( 'relay_sap' ) ;
     public final void rule__RelaySAPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14372:1: ( ( 'relay_sap' ) )
-            // InternalRoom.g:14373:1: ( 'relay_sap' )
+            // InternalRoom.g:14601:1: ( ( 'relay_sap' ) )
+            // InternalRoom.g:14602:1: ( 'relay_sap' )
             {
-            // InternalRoom.g:14373:1: ( 'relay_sap' )
-            // InternalRoom.g:14374:1: 'relay_sap'
+            // InternalRoom.g:14602:1: ( 'relay_sap' )
+            // InternalRoom.g:14603:1: 'relay_sap'
             {
              before(grammarAccess.getRelaySAPointAccess().getRelay_sapKeyword_0()); 
             match(input,92,FOLLOW_2); 
@@ -40256,14 +40915,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__Group__1"
-    // InternalRoom.g:14387:1: rule__RelaySAPoint__Group__1 : rule__RelaySAPoint__Group__1__Impl ;
+    // InternalRoom.g:14616:1: rule__RelaySAPoint__Group__1 : rule__RelaySAPoint__Group__1__Impl ;
     public final void rule__RelaySAPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14391:1: ( rule__RelaySAPoint__Group__1__Impl )
-            // InternalRoom.g:14392:2: rule__RelaySAPoint__Group__1__Impl
+            // InternalRoom.g:14620:1: ( rule__RelaySAPoint__Group__1__Impl )
+            // InternalRoom.g:14621:2: rule__RelaySAPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RelaySAPoint__Group__1__Impl();
@@ -40289,21 +40948,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__Group__1__Impl"
-    // InternalRoom.g:14398:1: rule__RelaySAPoint__Group__1__Impl : ( ( rule__RelaySAPoint__RelayAssignment_1 ) ) ;
+    // InternalRoom.g:14627:1: rule__RelaySAPoint__Group__1__Impl : ( ( rule__RelaySAPoint__RelayAssignment_1 ) ) ;
     public final void rule__RelaySAPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14402:1: ( ( ( rule__RelaySAPoint__RelayAssignment_1 ) ) )
-            // InternalRoom.g:14403:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
+            // InternalRoom.g:14631:1: ( ( ( rule__RelaySAPoint__RelayAssignment_1 ) ) )
+            // InternalRoom.g:14632:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
             {
-            // InternalRoom.g:14403:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
-            // InternalRoom.g:14404:1: ( rule__RelaySAPoint__RelayAssignment_1 )
+            // InternalRoom.g:14632:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
+            // InternalRoom.g:14633:1: ( rule__RelaySAPoint__RelayAssignment_1 )
             {
              before(grammarAccess.getRelaySAPointAccess().getRelayAssignment_1()); 
-            // InternalRoom.g:14405:1: ( rule__RelaySAPoint__RelayAssignment_1 )
-            // InternalRoom.g:14405:2: rule__RelaySAPoint__RelayAssignment_1
+            // InternalRoom.g:14634:1: ( rule__RelaySAPoint__RelayAssignment_1 )
+            // InternalRoom.g:14634:2: rule__RelaySAPoint__RelayAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RelaySAPoint__RelayAssignment_1();
@@ -40336,16 +40995,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__0"
-    // InternalRoom.g:14419:1: rule__SPPoint__Group__0 : rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1 ;
+    // InternalRoom.g:14648:1: rule__SPPoint__Group__0 : rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1 ;
     public final void rule__SPPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14423:1: ( rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1 )
-            // InternalRoom.g:14424:2: rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1
+            // InternalRoom.g:14652:1: ( rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1 )
+            // InternalRoom.g:14653:2: rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1
             {
-            pushFollow(FOLLOW_73);
+            pushFollow(FOLLOW_74);
             rule__SPPoint__Group__0__Impl();
 
             state._fsp--;
@@ -40374,21 +41033,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__0__Impl"
-    // InternalRoom.g:14431:1: rule__SPPoint__Group__0__Impl : ( ( rule__SPPoint__RefAssignment_0 ) ) ;
+    // InternalRoom.g:14660:1: rule__SPPoint__Group__0__Impl : ( ( rule__SPPoint__RefAssignment_0 ) ) ;
     public final void rule__SPPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14435:1: ( ( ( rule__SPPoint__RefAssignment_0 ) ) )
-            // InternalRoom.g:14436:1: ( ( rule__SPPoint__RefAssignment_0 ) )
+            // InternalRoom.g:14664:1: ( ( ( rule__SPPoint__RefAssignment_0 ) ) )
+            // InternalRoom.g:14665:1: ( ( rule__SPPoint__RefAssignment_0 ) )
             {
-            // InternalRoom.g:14436:1: ( ( rule__SPPoint__RefAssignment_0 ) )
-            // InternalRoom.g:14437:1: ( rule__SPPoint__RefAssignment_0 )
+            // InternalRoom.g:14665:1: ( ( rule__SPPoint__RefAssignment_0 ) )
+            // InternalRoom.g:14666:1: ( rule__SPPoint__RefAssignment_0 )
             {
              before(grammarAccess.getSPPointAccess().getRefAssignment_0()); 
-            // InternalRoom.g:14438:1: ( rule__SPPoint__RefAssignment_0 )
-            // InternalRoom.g:14438:2: rule__SPPoint__RefAssignment_0
+            // InternalRoom.g:14667:1: ( rule__SPPoint__RefAssignment_0 )
+            // InternalRoom.g:14667:2: rule__SPPoint__RefAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__RefAssignment_0();
@@ -40421,14 +41080,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__1"
-    // InternalRoom.g:14448:1: rule__SPPoint__Group__1 : rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2 ;
+    // InternalRoom.g:14677:1: rule__SPPoint__Group__1 : rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2 ;
     public final void rule__SPPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14452:1: ( rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2 )
-            // InternalRoom.g:14453:2: rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2
+            // InternalRoom.g:14681:1: ( rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2 )
+            // InternalRoom.g:14682:2: rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SPPoint__Group__1__Impl();
@@ -40459,17 +41118,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__1__Impl"
-    // InternalRoom.g:14460:1: rule__SPPoint__Group__1__Impl : ( '.' ) ;
+    // InternalRoom.g:14689:1: rule__SPPoint__Group__1__Impl : ( '.' ) ;
     public final void rule__SPPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14464:1: ( ( '.' ) )
-            // InternalRoom.g:14465:1: ( '.' )
+            // InternalRoom.g:14693:1: ( ( '.' ) )
+            // InternalRoom.g:14694:1: ( '.' )
             {
-            // InternalRoom.g:14465:1: ( '.' )
-            // InternalRoom.g:14466:1: '.'
+            // InternalRoom.g:14694:1: ( '.' )
+            // InternalRoom.g:14695:1: '.'
             {
              before(grammarAccess.getSPPointAccess().getFullStopKeyword_1()); 
             match(input,87,FOLLOW_2); 
@@ -40496,14 +41155,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__2"
-    // InternalRoom.g:14479:1: rule__SPPoint__Group__2 : rule__SPPoint__Group__2__Impl ;
+    // InternalRoom.g:14708:1: rule__SPPoint__Group__2 : rule__SPPoint__Group__2__Impl ;
     public final void rule__SPPoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14483:1: ( rule__SPPoint__Group__2__Impl )
-            // InternalRoom.g:14484:2: rule__SPPoint__Group__2__Impl
+            // InternalRoom.g:14712:1: ( rule__SPPoint__Group__2__Impl )
+            // InternalRoom.g:14713:2: rule__SPPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__Group__2__Impl();
@@ -40529,21 +41188,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__2__Impl"
-    // InternalRoom.g:14490:1: rule__SPPoint__Group__2__Impl : ( ( rule__SPPoint__ServiceAssignment_2 ) ) ;
+    // InternalRoom.g:14719:1: rule__SPPoint__Group__2__Impl : ( ( rule__SPPoint__ServiceAssignment_2 ) ) ;
     public final void rule__SPPoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14494:1: ( ( ( rule__SPPoint__ServiceAssignment_2 ) ) )
-            // InternalRoom.g:14495:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
+            // InternalRoom.g:14723:1: ( ( ( rule__SPPoint__ServiceAssignment_2 ) ) )
+            // InternalRoom.g:14724:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
             {
-            // InternalRoom.g:14495:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
-            // InternalRoom.g:14496:1: ( rule__SPPoint__ServiceAssignment_2 )
+            // InternalRoom.g:14724:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
+            // InternalRoom.g:14725:1: ( rule__SPPoint__ServiceAssignment_2 )
             {
              before(grammarAccess.getSPPointAccess().getServiceAssignment_2()); 
-            // InternalRoom.g:14497:1: ( rule__SPPoint__ServiceAssignment_2 )
-            // InternalRoom.g:14497:2: rule__SPPoint__ServiceAssignment_2
+            // InternalRoom.g:14726:1: ( rule__SPPoint__ServiceAssignment_2 )
+            // InternalRoom.g:14726:2: rule__SPPoint__ServiceAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__ServiceAssignment_2();
@@ -40576,16 +41235,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__0"
-    // InternalRoom.g:14513:1: rule__ActorRef__Group__0 : rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1 ;
+    // InternalRoom.g:14742:1: rule__ActorRef__Group__0 : rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1 ;
     public final void rule__ActorRef__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14517:1: ( rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1 )
-            // InternalRoom.g:14518:2: rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1
+            // InternalRoom.g:14746:1: ( rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1 )
+            // InternalRoom.g:14747:2: rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1
             {
-            pushFollow(FOLLOW_76);
+            pushFollow(FOLLOW_77);
             rule__ActorRef__Group__0__Impl();
 
             state._fsp--;
@@ -40614,29 +41273,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__0__Impl"
-    // InternalRoom.g:14525:1: rule__ActorRef__Group__0__Impl : ( ( rule__ActorRef__RefTypeAssignment_0 )? ) ;
+    // InternalRoom.g:14754:1: rule__ActorRef__Group__0__Impl : ( ( rule__ActorRef__RefTypeAssignment_0 )? ) ;
     public final void rule__ActorRef__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14529:1: ( ( ( rule__ActorRef__RefTypeAssignment_0 )? ) )
-            // InternalRoom.g:14530:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
+            // InternalRoom.g:14758:1: ( ( ( rule__ActorRef__RefTypeAssignment_0 )? ) )
+            // InternalRoom.g:14759:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
             {
-            // InternalRoom.g:14530:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
-            // InternalRoom.g:14531:1: ( rule__ActorRef__RefTypeAssignment_0 )?
+            // InternalRoom.g:14759:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
+            // InternalRoom.g:14760:1: ( rule__ActorRef__RefTypeAssignment_0 )?
             {
              before(grammarAccess.getActorRefAccess().getRefTypeAssignment_0()); 
-            // InternalRoom.g:14532:1: ( rule__ActorRef__RefTypeAssignment_0 )?
-            int alt147=2;
-            int LA147_0 = input.LA(1);
+            // InternalRoom.g:14761:1: ( rule__ActorRef__RefTypeAssignment_0 )?
+            int alt150=2;
+            int LA150_0 = input.LA(1);
 
-            if ( ((LA147_0>=36 && LA147_0<=37)) ) {
-                alt147=1;
+            if ( ((LA150_0>=36 && LA150_0<=37)) ) {
+                alt150=1;
             }
-            switch (alt147) {
+            switch (alt150) {
                 case 1 :
-                    // InternalRoom.g:14532:2: rule__ActorRef__RefTypeAssignment_0
+                    // InternalRoom.g:14761:2: rule__ActorRef__RefTypeAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__RefTypeAssignment_0();
@@ -40672,14 +41331,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__1"
-    // InternalRoom.g:14542:1: rule__ActorRef__Group__1 : rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2 ;
+    // InternalRoom.g:14771:1: rule__ActorRef__Group__1 : rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2 ;
     public final void rule__ActorRef__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14546:1: ( rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2 )
-            // InternalRoom.g:14547:2: rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2
+            // InternalRoom.g:14775:1: ( rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2 )
+            // InternalRoom.g:14776:2: rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ActorRef__Group__1__Impl();
@@ -40710,17 +41369,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__1__Impl"
-    // InternalRoom.g:14554:1: rule__ActorRef__Group__1__Impl : ( 'ActorRef' ) ;
+    // InternalRoom.g:14783:1: rule__ActorRef__Group__1__Impl : ( 'ActorRef' ) ;
     public final void rule__ActorRef__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14558:1: ( ( 'ActorRef' ) )
-            // InternalRoom.g:14559:1: ( 'ActorRef' )
+            // InternalRoom.g:14787:1: ( ( 'ActorRef' ) )
+            // InternalRoom.g:14788:1: ( 'ActorRef' )
             {
-            // InternalRoom.g:14559:1: ( 'ActorRef' )
-            // InternalRoom.g:14560:1: 'ActorRef'
+            // InternalRoom.g:14788:1: ( 'ActorRef' )
+            // InternalRoom.g:14789:1: 'ActorRef'
             {
              before(grammarAccess.getActorRefAccess().getActorRefKeyword_1()); 
             match(input,93,FOLLOW_2); 
@@ -40747,14 +41406,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__2"
-    // InternalRoom.g:14573:1: rule__ActorRef__Group__2 : rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3 ;
+    // InternalRoom.g:14802:1: rule__ActorRef__Group__2 : rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3 ;
     public final void rule__ActorRef__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14577:1: ( rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3 )
-            // InternalRoom.g:14578:2: rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3
+            // InternalRoom.g:14806:1: ( rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3 )
+            // InternalRoom.g:14807:2: rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__ActorRef__Group__2__Impl();
@@ -40785,21 +41444,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__2__Impl"
-    // InternalRoom.g:14585:1: rule__ActorRef__Group__2__Impl : ( ( rule__ActorRef__NameAssignment_2 ) ) ;
+    // InternalRoom.g:14814:1: rule__ActorRef__Group__2__Impl : ( ( rule__ActorRef__NameAssignment_2 ) ) ;
     public final void rule__ActorRef__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14589:1: ( ( ( rule__ActorRef__NameAssignment_2 ) ) )
-            // InternalRoom.g:14590:1: ( ( rule__ActorRef__NameAssignment_2 ) )
+            // InternalRoom.g:14818:1: ( ( ( rule__ActorRef__NameAssignment_2 ) ) )
+            // InternalRoom.g:14819:1: ( ( rule__ActorRef__NameAssignment_2 ) )
             {
-            // InternalRoom.g:14590:1: ( ( rule__ActorRef__NameAssignment_2 ) )
-            // InternalRoom.g:14591:1: ( rule__ActorRef__NameAssignment_2 )
+            // InternalRoom.g:14819:1: ( ( rule__ActorRef__NameAssignment_2 ) )
+            // InternalRoom.g:14820:1: ( rule__ActorRef__NameAssignment_2 )
             {
              before(grammarAccess.getActorRefAccess().getNameAssignment_2()); 
-            // InternalRoom.g:14592:1: ( rule__ActorRef__NameAssignment_2 )
-            // InternalRoom.g:14592:2: rule__ActorRef__NameAssignment_2
+            // InternalRoom.g:14821:1: ( rule__ActorRef__NameAssignment_2 )
+            // InternalRoom.g:14821:2: rule__ActorRef__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__NameAssignment_2();
@@ -40832,14 +41491,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__3"
-    // InternalRoom.g:14602:1: rule__ActorRef__Group__3 : rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4 ;
+    // InternalRoom.g:14831:1: rule__ActorRef__Group__3 : rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4 ;
     public final void rule__ActorRef__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14606:1: ( rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4 )
-            // InternalRoom.g:14607:2: rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4
+            // InternalRoom.g:14835:1: ( rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4 )
+            // InternalRoom.g:14836:2: rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4
             {
             pushFollow(FOLLOW_28);
             rule__ActorRef__Group__3__Impl();
@@ -40870,29 +41529,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__3__Impl"
-    // InternalRoom.g:14614:1: rule__ActorRef__Group__3__Impl : ( ( rule__ActorRef__MultiplicityAssignment_3 )? ) ;
+    // InternalRoom.g:14843:1: rule__ActorRef__Group__3__Impl : ( ( rule__ActorRef__MultiplicityAssignment_3 )? ) ;
     public final void rule__ActorRef__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14618:1: ( ( ( rule__ActorRef__MultiplicityAssignment_3 )? ) )
-            // InternalRoom.g:14619:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:14847:1: ( ( ( rule__ActorRef__MultiplicityAssignment_3 )? ) )
+            // InternalRoom.g:14848:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
             {
-            // InternalRoom.g:14619:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
-            // InternalRoom.g:14620:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
+            // InternalRoom.g:14848:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:14849:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
             {
              before(grammarAccess.getActorRefAccess().getMultiplicityAssignment_3()); 
-            // InternalRoom.g:14621:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
-            int alt148=2;
-            int LA148_0 = input.LA(1);
+            // InternalRoom.g:14850:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
+            int alt151=2;
+            int LA151_0 = input.LA(1);
 
-            if ( (LA148_0==62) ) {
-                alt148=1;
+            if ( (LA151_0==62) ) {
+                alt151=1;
             }
-            switch (alt148) {
+            switch (alt151) {
                 case 1 :
-                    // InternalRoom.g:14621:2: rule__ActorRef__MultiplicityAssignment_3
+                    // InternalRoom.g:14850:2: rule__ActorRef__MultiplicityAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__MultiplicityAssignment_3();
@@ -40928,14 +41587,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__4"
-    // InternalRoom.g:14631:1: rule__ActorRef__Group__4 : rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5 ;
+    // InternalRoom.g:14860:1: rule__ActorRef__Group__4 : rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5 ;
     public final void rule__ActorRef__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14635:1: ( rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5 )
-            // InternalRoom.g:14636:2: rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5
+            // InternalRoom.g:14864:1: ( rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5 )
+            // InternalRoom.g:14865:2: rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5
             {
             pushFollow(FOLLOW_3);
             rule__ActorRef__Group__4__Impl();
@@ -40966,17 +41625,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__4__Impl"
-    // InternalRoom.g:14643:1: rule__ActorRef__Group__4__Impl : ( ':' ) ;
+    // InternalRoom.g:14872:1: rule__ActorRef__Group__4__Impl : ( ':' ) ;
     public final void rule__ActorRef__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14647:1: ( ( ':' ) )
-            // InternalRoom.g:14648:1: ( ':' )
+            // InternalRoom.g:14876:1: ( ( ':' ) )
+            // InternalRoom.g:14877:1: ( ':' )
             {
-            // InternalRoom.g:14648:1: ( ':' )
-            // InternalRoom.g:14649:1: ':'
+            // InternalRoom.g:14877:1: ( ':' )
+            // InternalRoom.g:14878:1: ':'
             {
              before(grammarAccess.getActorRefAccess().getColonKeyword_4()); 
             match(input,46,FOLLOW_2); 
@@ -41003,14 +41662,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__5"
-    // InternalRoom.g:14662:1: rule__ActorRef__Group__5 : rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6 ;
+    // InternalRoom.g:14891:1: rule__ActorRef__Group__5 : rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6 ;
     public final void rule__ActorRef__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14666:1: ( rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6 )
-            // InternalRoom.g:14667:2: rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6
+            // InternalRoom.g:14895:1: ( rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6 )
+            // InternalRoom.g:14896:2: rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6
             {
             pushFollow(FOLLOW_14);
             rule__ActorRef__Group__5__Impl();
@@ -41041,21 +41700,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__5__Impl"
-    // InternalRoom.g:14674:1: rule__ActorRef__Group__5__Impl : ( ( rule__ActorRef__TypeAssignment_5 ) ) ;
+    // InternalRoom.g:14903:1: rule__ActorRef__Group__5__Impl : ( ( rule__ActorRef__TypeAssignment_5 ) ) ;
     public final void rule__ActorRef__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14678:1: ( ( ( rule__ActorRef__TypeAssignment_5 ) ) )
-            // InternalRoom.g:14679:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
+            // InternalRoom.g:14907:1: ( ( ( rule__ActorRef__TypeAssignment_5 ) ) )
+            // InternalRoom.g:14908:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
             {
-            // InternalRoom.g:14679:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
-            // InternalRoom.g:14680:1: ( rule__ActorRef__TypeAssignment_5 )
+            // InternalRoom.g:14908:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
+            // InternalRoom.g:14909:1: ( rule__ActorRef__TypeAssignment_5 )
             {
              before(grammarAccess.getActorRefAccess().getTypeAssignment_5()); 
-            // InternalRoom.g:14681:1: ( rule__ActorRef__TypeAssignment_5 )
-            // InternalRoom.g:14681:2: rule__ActorRef__TypeAssignment_5
+            // InternalRoom.g:14910:1: ( rule__ActorRef__TypeAssignment_5 )
+            // InternalRoom.g:14910:2: rule__ActorRef__TypeAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__TypeAssignment_5();
@@ -41088,14 +41747,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__6"
-    // InternalRoom.g:14691:1: rule__ActorRef__Group__6 : rule__ActorRef__Group__6__Impl ;
+    // InternalRoom.g:14920:1: rule__ActorRef__Group__6 : rule__ActorRef__Group__6__Impl ;
     public final void rule__ActorRef__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14695:1: ( rule__ActorRef__Group__6__Impl )
-            // InternalRoom.g:14696:2: rule__ActorRef__Group__6__Impl
+            // InternalRoom.g:14924:1: ( rule__ActorRef__Group__6__Impl )
+            // InternalRoom.g:14925:2: rule__ActorRef__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__Group__6__Impl();
@@ -41121,29 +41780,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__6__Impl"
-    // InternalRoom.g:14702:1: rule__ActorRef__Group__6__Impl : ( ( rule__ActorRef__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:14931:1: rule__ActorRef__Group__6__Impl : ( ( rule__ActorRef__DocuAssignment_6 )? ) ;
     public final void rule__ActorRef__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14706:1: ( ( ( rule__ActorRef__DocuAssignment_6 )? ) )
-            // InternalRoom.g:14707:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
+            // InternalRoom.g:14935:1: ( ( ( rule__ActorRef__DocuAssignment_6 )? ) )
+            // InternalRoom.g:14936:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:14707:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
-            // InternalRoom.g:14708:1: ( rule__ActorRef__DocuAssignment_6 )?
+            // InternalRoom.g:14936:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
+            // InternalRoom.g:14937:1: ( rule__ActorRef__DocuAssignment_6 )?
             {
              before(grammarAccess.getActorRefAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:14709:1: ( rule__ActorRef__DocuAssignment_6 )?
-            int alt149=2;
-            int LA149_0 = input.LA(1);
+            // InternalRoom.g:14938:1: ( rule__ActorRef__DocuAssignment_6 )?
+            int alt152=2;
+            int LA152_0 = input.LA(1);
 
-            if ( (LA149_0==62) ) {
-                alt149=1;
+            if ( (LA152_0==62) ) {
+                alt152=1;
             }
-            switch (alt149) {
+            switch (alt152) {
                 case 1 :
-                    // InternalRoom.g:14709:2: rule__ActorRef__DocuAssignment_6
+                    // InternalRoom.g:14938:2: rule__ActorRef__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__DocuAssignment_6();
@@ -41179,16 +41838,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__0"
-    // InternalRoom.g:14733:1: rule__MULTIPLICITY__Group__0 : rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1 ;
+    // InternalRoom.g:14962:1: rule__MULTIPLICITY__Group__0 : rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1 ;
     public final void rule__MULTIPLICITY__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14737:1: ( rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1 )
-            // InternalRoom.g:14738:2: rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1
+            // InternalRoom.g:14966:1: ( rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1 )
+            // InternalRoom.g:14967:2: rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1
             {
-            pushFollow(FOLLOW_77);
+            pushFollow(FOLLOW_78);
             rule__MULTIPLICITY__Group__0__Impl();
 
             state._fsp--;
@@ -41217,17 +41876,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__0__Impl"
-    // InternalRoom.g:14745:1: rule__MULTIPLICITY__Group__0__Impl : ( '[' ) ;
+    // InternalRoom.g:14974:1: rule__MULTIPLICITY__Group__0__Impl : ( '[' ) ;
     public final void rule__MULTIPLICITY__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14749:1: ( ( '[' ) )
-            // InternalRoom.g:14750:1: ( '[' )
+            // InternalRoom.g:14978:1: ( ( '[' ) )
+            // InternalRoom.g:14979:1: ( '[' )
             {
-            // InternalRoom.g:14750:1: ( '[' )
-            // InternalRoom.g:14751:1: '['
+            // InternalRoom.g:14979:1: ( '[' )
+            // InternalRoom.g:14980:1: '['
             {
              before(grammarAccess.getMULTIPLICITYAccess().getLeftSquareBracketKeyword_0()); 
             match(input,62,FOLLOW_2); 
@@ -41254,14 +41913,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__1"
-    // InternalRoom.g:14764:1: rule__MULTIPLICITY__Group__1 : rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2 ;
+    // InternalRoom.g:14993:1: rule__MULTIPLICITY__Group__1 : rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2 ;
     public final void rule__MULTIPLICITY__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14768:1: ( rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2 )
-            // InternalRoom.g:14769:2: rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2
+            // InternalRoom.g:14997:1: ( rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2 )
+            // InternalRoom.g:14998:2: rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2
             {
             pushFollow(FOLLOW_31);
             rule__MULTIPLICITY__Group__1__Impl();
@@ -41292,21 +41951,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__1__Impl"
-    // InternalRoom.g:14776:1: rule__MULTIPLICITY__Group__1__Impl : ( ( rule__MULTIPLICITY__Alternatives_1 ) ) ;
+    // InternalRoom.g:15005:1: rule__MULTIPLICITY__Group__1__Impl : ( ( rule__MULTIPLICITY__Alternatives_1 ) ) ;
     public final void rule__MULTIPLICITY__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14780:1: ( ( ( rule__MULTIPLICITY__Alternatives_1 ) ) )
-            // InternalRoom.g:14781:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
+            // InternalRoom.g:15009:1: ( ( ( rule__MULTIPLICITY__Alternatives_1 ) ) )
+            // InternalRoom.g:15010:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
             {
-            // InternalRoom.g:14781:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
-            // InternalRoom.g:14782:1: ( rule__MULTIPLICITY__Alternatives_1 )
+            // InternalRoom.g:15010:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
+            // InternalRoom.g:15011:1: ( rule__MULTIPLICITY__Alternatives_1 )
             {
              before(grammarAccess.getMULTIPLICITYAccess().getAlternatives_1()); 
-            // InternalRoom.g:14783:1: ( rule__MULTIPLICITY__Alternatives_1 )
-            // InternalRoom.g:14783:2: rule__MULTIPLICITY__Alternatives_1
+            // InternalRoom.g:15012:1: ( rule__MULTIPLICITY__Alternatives_1 )
+            // InternalRoom.g:15012:2: rule__MULTIPLICITY__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__MULTIPLICITY__Alternatives_1();
@@ -41339,14 +41998,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__2"
-    // InternalRoom.g:14793:1: rule__MULTIPLICITY__Group__2 : rule__MULTIPLICITY__Group__2__Impl ;
+    // InternalRoom.g:15022:1: rule__MULTIPLICITY__Group__2 : rule__MULTIPLICITY__Group__2__Impl ;
     public final void rule__MULTIPLICITY__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14797:1: ( rule__MULTIPLICITY__Group__2__Impl )
-            // InternalRoom.g:14798:2: rule__MULTIPLICITY__Group__2__Impl
+            // InternalRoom.g:15026:1: ( rule__MULTIPLICITY__Group__2__Impl )
+            // InternalRoom.g:15027:2: rule__MULTIPLICITY__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__MULTIPLICITY__Group__2__Impl();
@@ -41372,17 +42031,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__2__Impl"
-    // InternalRoom.g:14804:1: rule__MULTIPLICITY__Group__2__Impl : ( ']' ) ;
+    // InternalRoom.g:15033:1: rule__MULTIPLICITY__Group__2__Impl : ( ']' ) ;
     public final void rule__MULTIPLICITY__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14808:1: ( ( ']' ) )
-            // InternalRoom.g:14809:1: ( ']' )
+            // InternalRoom.g:15037:1: ( ( ']' ) )
+            // InternalRoom.g:15038:1: ( ']' )
             {
-            // InternalRoom.g:14809:1: ( ']' )
-            // InternalRoom.g:14810:1: ']'
+            // InternalRoom.g:15038:1: ( ']' )
+            // InternalRoom.g:15039:1: ']'
             {
              before(grammarAccess.getMULTIPLICITYAccess().getRightSquareBracketKeyword_2()); 
             match(input,63,FOLLOW_2); 
@@ -41409,14 +42068,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__0"
-    // InternalRoom.g:14829:1: rule__StateGraph__Group__0 : rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ;
+    // InternalRoom.g:15058:1: rule__StateGraph__Group__0 : rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ;
     public final void rule__StateGraph__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14833:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 )
-            // InternalRoom.g:14834:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1
+            // InternalRoom.g:15062:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 )
+            // InternalRoom.g:15063:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1
             {
             pushFollow(FOLLOW_40);
             rule__StateGraph__Group__0__Impl();
@@ -41447,21 +42106,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__0__Impl"
-    // InternalRoom.g:14841:1: rule__StateGraph__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:15070:1: rule__StateGraph__Group__0__Impl : ( () ) ;
     public final void rule__StateGraph__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14845:1: ( ( () ) )
-            // InternalRoom.g:14846:1: ( () )
+            // InternalRoom.g:15074:1: ( ( () ) )
+            // InternalRoom.g:15075:1: ( () )
             {
-            // InternalRoom.g:14846:1: ( () )
-            // InternalRoom.g:14847:1: ()
+            // InternalRoom.g:15075:1: ( () )
+            // InternalRoom.g:15076:1: ()
             {
              before(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); 
-            // InternalRoom.g:14848:1: ()
-            // InternalRoom.g:14850:1: 
+            // InternalRoom.g:15077:1: ()
+            // InternalRoom.g:15079:1: 
             {
             }
 
@@ -41484,16 +42143,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__1"
-    // InternalRoom.g:14860:1: rule__StateGraph__Group__1 : rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ;
+    // InternalRoom.g:15089:1: rule__StateGraph__Group__1 : rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ;
     public final void rule__StateGraph__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14864:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 )
-            // InternalRoom.g:14865:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2
+            // InternalRoom.g:15093:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 )
+            // InternalRoom.g:15094:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2
             {
-            pushFollow(FOLLOW_78);
+            pushFollow(FOLLOW_79);
             rule__StateGraph__Group__1__Impl();
 
             state._fsp--;
@@ -41522,17 +42181,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__1__Impl"
-    // InternalRoom.g:14872:1: rule__StateGraph__Group__1__Impl : ( '{' ) ;
+    // InternalRoom.g:15101:1: rule__StateGraph__Group__1__Impl : ( '{' ) ;
     public final void rule__StateGraph__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14876:1: ( ( '{' ) )
-            // InternalRoom.g:14877:1: ( '{' )
+            // InternalRoom.g:15105:1: ( ( '{' ) )
+            // InternalRoom.g:15106:1: ( '{' )
             {
-            // InternalRoom.g:14877:1: ( '{' )
-            // InternalRoom.g:14878:1: '{'
+            // InternalRoom.g:15106:1: ( '{' )
+            // InternalRoom.g:15107:1: '{'
             {
              before(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); 
             match(input,44,FOLLOW_2); 
@@ -41559,16 +42218,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__2"
-    // InternalRoom.g:14891:1: rule__StateGraph__Group__2 : rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ;
+    // InternalRoom.g:15120:1: rule__StateGraph__Group__2 : rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ;
     public final void rule__StateGraph__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14895:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 )
-            // InternalRoom.g:14896:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3
+            // InternalRoom.g:15124:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 )
+            // InternalRoom.g:15125:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3
             {
-            pushFollow(FOLLOW_78);
+            pushFollow(FOLLOW_79);
             rule__StateGraph__Group__2__Impl();
 
             state._fsp--;
@@ -41597,35 +42256,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__2__Impl"
-    // InternalRoom.g:14903:1: rule__StateGraph__Group__2__Impl : ( ( rule__StateGraph__Alternatives_2 )* ) ;
+    // InternalRoom.g:15132:1: rule__StateGraph__Group__2__Impl : ( ( rule__StateGraph__Alternatives_2 )* ) ;
     public final void rule__StateGraph__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14907:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) )
-            // InternalRoom.g:14908:1: ( ( rule__StateGraph__Alternatives_2 )* )
+            // InternalRoom.g:15136:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) )
+            // InternalRoom.g:15137:1: ( ( rule__StateGraph__Alternatives_2 )* )
             {
-            // InternalRoom.g:14908:1: ( ( rule__StateGraph__Alternatives_2 )* )
-            // InternalRoom.g:14909:1: ( rule__StateGraph__Alternatives_2 )*
+            // InternalRoom.g:15137:1: ( ( rule__StateGraph__Alternatives_2 )* )
+            // InternalRoom.g:15138:1: ( rule__StateGraph__Alternatives_2 )*
             {
              before(grammarAccess.getStateGraphAccess().getAlternatives_2()); 
-            // InternalRoom.g:14910:1: ( rule__StateGraph__Alternatives_2 )*
-            loop150:
+            // InternalRoom.g:15139:1: ( rule__StateGraph__Alternatives_2 )*
+            loop153:
             do {
-                int alt150=2;
-                int LA150_0 = input.LA(1);
+                int alt153=2;
+                int LA153_0 = input.LA(1);
 
-                if ( (LA150_0==95||(LA150_0>=100 && LA150_0<=105)||LA150_0==112||LA150_0==131) ) {
-                    alt150=1;
+                if ( (LA153_0==95||(LA153_0>=100 && LA153_0<=105)||LA153_0==112||LA153_0==131) ) {
+                    alt153=1;
                 }
 
 
-                switch (alt150) {
+                switch (alt153) {
             	case 1 :
-            	    // InternalRoom.g:14910:2: rule__StateGraph__Alternatives_2
+            	    // InternalRoom.g:15139:2: rule__StateGraph__Alternatives_2
             	    {
-            	    pushFollow(FOLLOW_79);
+            	    pushFollow(FOLLOW_80);
             	    rule__StateGraph__Alternatives_2();
 
             	    state._fsp--;
@@ -41635,7 +42294,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop150;
+            	    break loop153;
                 }
             } while (true);
 
@@ -41662,14 +42321,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__3"
-    // InternalRoom.g:14920:1: rule__StateGraph__Group__3 : rule__StateGraph__Group__3__Impl ;
+    // InternalRoom.g:15149:1: rule__StateGraph__Group__3 : rule__StateGraph__Group__3__Impl ;
     public final void rule__StateGraph__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14924:1: ( rule__StateGraph__Group__3__Impl )
-            // InternalRoom.g:14925:2: rule__StateGraph__Group__3__Impl
+            // InternalRoom.g:15153:1: ( rule__StateGraph__Group__3__Impl )
+            // InternalRoom.g:15154:2: rule__StateGraph__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateGraph__Group__3__Impl();
@@ -41695,17 +42354,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__3__Impl"
-    // InternalRoom.g:14931:1: rule__StateGraph__Group__3__Impl : ( '}' ) ;
+    // InternalRoom.g:15160:1: rule__StateGraph__Group__3__Impl : ( '}' ) ;
     public final void rule__StateGraph__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14935:1: ( ( '}' ) )
-            // InternalRoom.g:14936:1: ( '}' )
+            // InternalRoom.g:15164:1: ( ( '}' ) )
+            // InternalRoom.g:15165:1: ( '}' )
             {
-            // InternalRoom.g:14936:1: ( '}' )
-            // InternalRoom.g:14937:1: '}'
+            // InternalRoom.g:15165:1: ( '}' )
+            // InternalRoom.g:15166:1: '}'
             {
              before(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); 
             match(input,45,FOLLOW_2); 
@@ -41732,16 +42391,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__0"
-    // InternalRoom.g:14958:1: rule__StateMachine__Group__0 : rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ;
+    // InternalRoom.g:15187:1: rule__StateMachine__Group__0 : rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ;
     public final void rule__StateMachine__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14962:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 )
-            // InternalRoom.g:14963:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1
+            // InternalRoom.g:15191:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 )
+            // InternalRoom.g:15192:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1
             {
-            pushFollow(FOLLOW_80);
+            pushFollow(FOLLOW_81);
             rule__StateMachine__Group__0__Impl();
 
             state._fsp--;
@@ -41770,21 +42429,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__0__Impl"
-    // InternalRoom.g:14970:1: rule__StateMachine__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:15199:1: rule__StateMachine__Group__0__Impl : ( () ) ;
     public final void rule__StateMachine__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14974:1: ( ( () ) )
-            // InternalRoom.g:14975:1: ( () )
+            // InternalRoom.g:15203:1: ( ( () ) )
+            // InternalRoom.g:15204:1: ( () )
             {
-            // InternalRoom.g:14975:1: ( () )
-            // InternalRoom.g:14976:1: ()
+            // InternalRoom.g:15204:1: ( () )
+            // InternalRoom.g:15205:1: ()
             {
              before(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); 
-            // InternalRoom.g:14977:1: ()
-            // InternalRoom.g:14979:1: 
+            // InternalRoom.g:15206:1: ()
+            // InternalRoom.g:15208:1: 
             {
             }
 
@@ -41807,14 +42466,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__1"
-    // InternalRoom.g:14989:1: rule__StateMachine__Group__1 : rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ;
+    // InternalRoom.g:15218:1: rule__StateMachine__Group__1 : rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ;
     public final void rule__StateMachine__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:14993:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 )
-            // InternalRoom.g:14994:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2
+            // InternalRoom.g:15222:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 )
+            // InternalRoom.g:15223:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2
             {
             pushFollow(FOLLOW_40);
             rule__StateMachine__Group__1__Impl();
@@ -41845,17 +42504,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__1__Impl"
-    // InternalRoom.g:15001:1: rule__StateMachine__Group__1__Impl : ( 'StateMachine' ) ;
+    // InternalRoom.g:15230:1: rule__StateMachine__Group__1__Impl : ( 'StateMachine' ) ;
     public final void rule__StateMachine__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15005:1: ( ( 'StateMachine' ) )
-            // InternalRoom.g:15006:1: ( 'StateMachine' )
+            // InternalRoom.g:15234:1: ( ( 'StateMachine' ) )
+            // InternalRoom.g:15235:1: ( 'StateMachine' )
             {
-            // InternalRoom.g:15006:1: ( 'StateMachine' )
-            // InternalRoom.g:15007:1: 'StateMachine'
+            // InternalRoom.g:15235:1: ( 'StateMachine' )
+            // InternalRoom.g:15236:1: 'StateMachine'
             {
              before(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); 
             match(input,94,FOLLOW_2); 
@@ -41882,16 +42541,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__2"
-    // InternalRoom.g:15020:1: rule__StateMachine__Group__2 : rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ;
+    // InternalRoom.g:15249:1: rule__StateMachine__Group__2 : rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ;
     public final void rule__StateMachine__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15024:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 )
-            // InternalRoom.g:15025:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3
+            // InternalRoom.g:15253:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 )
+            // InternalRoom.g:15254:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3
             {
-            pushFollow(FOLLOW_78);
+            pushFollow(FOLLOW_79);
             rule__StateMachine__Group__2__Impl();
 
             state._fsp--;
@@ -41920,17 +42579,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__2__Impl"
-    // InternalRoom.g:15032:1: rule__StateMachine__Group__2__Impl : ( '{' ) ;
+    // InternalRoom.g:15261:1: rule__StateMachine__Group__2__Impl : ( '{' ) ;
     public final void rule__StateMachine__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15036:1: ( ( '{' ) )
-            // InternalRoom.g:15037:1: ( '{' )
+            // InternalRoom.g:15265:1: ( ( '{' ) )
+            // InternalRoom.g:15266:1: ( '{' )
             {
-            // InternalRoom.g:15037:1: ( '{' )
-            // InternalRoom.g:15038:1: '{'
+            // InternalRoom.g:15266:1: ( '{' )
+            // InternalRoom.g:15267:1: '{'
             {
              before(grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2()); 
             match(input,44,FOLLOW_2); 
@@ -41957,16 +42616,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__3"
-    // InternalRoom.g:15051:1: rule__StateMachine__Group__3 : rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ;
+    // InternalRoom.g:15280:1: rule__StateMachine__Group__3 : rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ;
     public final void rule__StateMachine__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15055:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 )
-            // InternalRoom.g:15056:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4
+            // InternalRoom.g:15284:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 )
+            // InternalRoom.g:15285:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4
             {
-            pushFollow(FOLLOW_78);
+            pushFollow(FOLLOW_79);
             rule__StateMachine__Group__3__Impl();
 
             state._fsp--;
@@ -41995,35 +42654,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__3__Impl"
-    // InternalRoom.g:15063:1: rule__StateMachine__Group__3__Impl : ( ( rule__StateMachine__Alternatives_3 )* ) ;
+    // InternalRoom.g:15292:1: rule__StateMachine__Group__3__Impl : ( ( rule__StateMachine__Alternatives_3 )* ) ;
     public final void rule__StateMachine__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15067:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) )
-            // InternalRoom.g:15068:1: ( ( rule__StateMachine__Alternatives_3 )* )
+            // InternalRoom.g:15296:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) )
+            // InternalRoom.g:15297:1: ( ( rule__StateMachine__Alternatives_3 )* )
             {
-            // InternalRoom.g:15068:1: ( ( rule__StateMachine__Alternatives_3 )* )
-            // InternalRoom.g:15069:1: ( rule__StateMachine__Alternatives_3 )*
+            // InternalRoom.g:15297:1: ( ( rule__StateMachine__Alternatives_3 )* )
+            // InternalRoom.g:15298:1: ( rule__StateMachine__Alternatives_3 )*
             {
              before(grammarAccess.getStateMachineAccess().getAlternatives_3()); 
-            // InternalRoom.g:15070:1: ( rule__StateMachine__Alternatives_3 )*
-            loop151:
+            // InternalRoom.g:15299:1: ( rule__StateMachine__Alternatives_3 )*
+            loop154:
             do {
-                int alt151=2;
-                int LA151_0 = input.LA(1);
+                int alt154=2;
+                int LA154_0 = input.LA(1);
 
-                if ( (LA151_0==95||(LA151_0>=100 && LA151_0<=105)||LA151_0==112||LA151_0==131) ) {
-                    alt151=1;
+                if ( (LA154_0==95||(LA154_0>=100 && LA154_0<=105)||LA154_0==112||LA154_0==131) ) {
+                    alt154=1;
                 }
 
 
-                switch (alt151) {
+                switch (alt154) {
             	case 1 :
-            	    // InternalRoom.g:15070:2: rule__StateMachine__Alternatives_3
+            	    // InternalRoom.g:15299:2: rule__StateMachine__Alternatives_3
             	    {
-            	    pushFollow(FOLLOW_79);
+            	    pushFollow(FOLLOW_80);
             	    rule__StateMachine__Alternatives_3();
 
             	    state._fsp--;
@@ -42033,7 +42692,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop151;
+            	    break loop154;
                 }
             } while (true);
 
@@ -42060,14 +42719,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__4"
-    // InternalRoom.g:15080:1: rule__StateMachine__Group__4 : rule__StateMachine__Group__4__Impl ;
+    // InternalRoom.g:15309:1: rule__StateMachine__Group__4 : rule__StateMachine__Group__4__Impl ;
     public final void rule__StateMachine__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15084:1: ( rule__StateMachine__Group__4__Impl )
-            // InternalRoom.g:15085:2: rule__StateMachine__Group__4__Impl
+            // InternalRoom.g:15313:1: ( rule__StateMachine__Group__4__Impl )
+            // InternalRoom.g:15314:2: rule__StateMachine__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateMachine__Group__4__Impl();
@@ -42093,17 +42752,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__4__Impl"
-    // InternalRoom.g:15091:1: rule__StateMachine__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:15320:1: rule__StateMachine__Group__4__Impl : ( '}' ) ;
     public final void rule__StateMachine__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15095:1: ( ( '}' ) )
-            // InternalRoom.g:15096:1: ( '}' )
+            // InternalRoom.g:15324:1: ( ( '}' ) )
+            // InternalRoom.g:15325:1: ( '}' )
             {
-            // InternalRoom.g:15096:1: ( '}' )
-            // InternalRoom.g:15097:1: '}'
+            // InternalRoom.g:15325:1: ( '}' )
+            // InternalRoom.g:15326:1: '}'
             {
              before(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -42130,14 +42789,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__0"
-    // InternalRoom.g:15120:1: rule__SimpleState__Group__0 : rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ;
+    // InternalRoom.g:15349:1: rule__SimpleState__Group__0 : rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ;
     public final void rule__SimpleState__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15124:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 )
-            // InternalRoom.g:15125:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1
+            // InternalRoom.g:15353:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 )
+            // InternalRoom.g:15354:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SimpleState__Group__0__Impl();
@@ -42168,17 +42827,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__0__Impl"
-    // InternalRoom.g:15132:1: rule__SimpleState__Group__0__Impl : ( 'State' ) ;
+    // InternalRoom.g:15361:1: rule__SimpleState__Group__0__Impl : ( 'State' ) ;
     public final void rule__SimpleState__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15136:1: ( ( 'State' ) )
-            // InternalRoom.g:15137:1: ( 'State' )
+            // InternalRoom.g:15365:1: ( ( 'State' ) )
+            // InternalRoom.g:15366:1: ( 'State' )
             {
-            // InternalRoom.g:15137:1: ( 'State' )
-            // InternalRoom.g:15138:1: 'State'
+            // InternalRoom.g:15366:1: ( 'State' )
+            // InternalRoom.g:15367:1: 'State'
             {
              before(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); 
             match(input,95,FOLLOW_2); 
@@ -42205,14 +42864,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__1"
-    // InternalRoom.g:15151:1: rule__SimpleState__Group__1 : rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ;
+    // InternalRoom.g:15380:1: rule__SimpleState__Group__1 : rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ;
     public final void rule__SimpleState__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15155:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 )
-            // InternalRoom.g:15156:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2
+            // InternalRoom.g:15384:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 )
+            // InternalRoom.g:15385:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__SimpleState__Group__1__Impl();
@@ -42243,21 +42902,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__1__Impl"
-    // InternalRoom.g:15163:1: rule__SimpleState__Group__1__Impl : ( ( rule__SimpleState__NameAssignment_1 ) ) ;
+    // InternalRoom.g:15392:1: rule__SimpleState__Group__1__Impl : ( ( rule__SimpleState__NameAssignment_1 ) ) ;
     public final void rule__SimpleState__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15167:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) )
-            // InternalRoom.g:15168:1: ( ( rule__SimpleState__NameAssignment_1 ) )
+            // InternalRoom.g:15396:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) )
+            // InternalRoom.g:15397:1: ( ( rule__SimpleState__NameAssignment_1 ) )
             {
-            // InternalRoom.g:15168:1: ( ( rule__SimpleState__NameAssignment_1 ) )
-            // InternalRoom.g:15169:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalRoom.g:15397:1: ( ( rule__SimpleState__NameAssignment_1 ) )
+            // InternalRoom.g:15398:1: ( rule__SimpleState__NameAssignment_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); 
-            // InternalRoom.g:15170:1: ( rule__SimpleState__NameAssignment_1 )
-            // InternalRoom.g:15170:2: rule__SimpleState__NameAssignment_1
+            // InternalRoom.g:15399:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalRoom.g:15399:2: rule__SimpleState__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__NameAssignment_1();
@@ -42290,14 +42949,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__2"
-    // InternalRoom.g:15180:1: rule__SimpleState__Group__2 : rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ;
+    // InternalRoom.g:15409:1: rule__SimpleState__Group__2 : rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ;
     public final void rule__SimpleState__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15184:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 )
-            // InternalRoom.g:15185:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3
+            // InternalRoom.g:15413:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 )
+            // InternalRoom.g:15414:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__SimpleState__Group__2__Impl();
@@ -42328,29 +42987,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__2__Impl"
-    // InternalRoom.g:15192:1: rule__SimpleState__Group__2__Impl : ( ( rule__SimpleState__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:15421:1: rule__SimpleState__Group__2__Impl : ( ( rule__SimpleState__DocuAssignment_2 )? ) ;
     public final void rule__SimpleState__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15196:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) )
-            // InternalRoom.g:15197:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
+            // InternalRoom.g:15425:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) )
+            // InternalRoom.g:15426:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:15197:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
-            // InternalRoom.g:15198:1: ( rule__SimpleState__DocuAssignment_2 )?
+            // InternalRoom.g:15426:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
+            // InternalRoom.g:15427:1: ( rule__SimpleState__DocuAssignment_2 )?
             {
              before(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:15199:1: ( rule__SimpleState__DocuAssignment_2 )?
-            int alt152=2;
-            int LA152_0 = input.LA(1);
+            // InternalRoom.g:15428:1: ( rule__SimpleState__DocuAssignment_2 )?
+            int alt155=2;
+            int LA155_0 = input.LA(1);
 
-            if ( (LA152_0==62) ) {
-                alt152=1;
+            if ( (LA155_0==62) ) {
+                alt155=1;
             }
-            switch (alt152) {
+            switch (alt155) {
                 case 1 :
-                    // InternalRoom.g:15199:2: rule__SimpleState__DocuAssignment_2
+                    // InternalRoom.g:15428:2: rule__SimpleState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__DocuAssignment_2();
@@ -42386,14 +43045,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__3"
-    // InternalRoom.g:15209:1: rule__SimpleState__Group__3 : rule__SimpleState__Group__3__Impl ;
+    // InternalRoom.g:15438:1: rule__SimpleState__Group__3 : rule__SimpleState__Group__3__Impl ;
     public final void rule__SimpleState__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15213:1: ( rule__SimpleState__Group__3__Impl )
-            // InternalRoom.g:15214:2: rule__SimpleState__Group__3__Impl
+            // InternalRoom.g:15442:1: ( rule__SimpleState__Group__3__Impl )
+            // InternalRoom.g:15443:2: rule__SimpleState__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group__3__Impl();
@@ -42419,29 +43078,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group__3__Impl"
-    // InternalRoom.g:15220:1: rule__SimpleState__Group__3__Impl : ( ( rule__SimpleState__Group_3__0 )? ) ;
+    // InternalRoom.g:15449:1: rule__SimpleState__Group__3__Impl : ( ( rule__SimpleState__Group_3__0 )? ) ;
     public final void rule__SimpleState__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15224:1: ( ( ( rule__SimpleState__Group_3__0 )? ) )
-            // InternalRoom.g:15225:1: ( ( rule__SimpleState__Group_3__0 )? )
+            // InternalRoom.g:15453:1: ( ( ( rule__SimpleState__Group_3__0 )? ) )
+            // InternalRoom.g:15454:1: ( ( rule__SimpleState__Group_3__0 )? )
             {
-            // InternalRoom.g:15225:1: ( ( rule__SimpleState__Group_3__0 )? )
-            // InternalRoom.g:15226:1: ( rule__SimpleState__Group_3__0 )?
+            // InternalRoom.g:15454:1: ( ( rule__SimpleState__Group_3__0 )? )
+            // InternalRoom.g:15455:1: ( rule__SimpleState__Group_3__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3()); 
-            // InternalRoom.g:15227:1: ( rule__SimpleState__Group_3__0 )?
-            int alt153=2;
-            int LA153_0 = input.LA(1);
+            // InternalRoom.g:15456:1: ( rule__SimpleState__Group_3__0 )?
+            int alt156=2;
+            int LA156_0 = input.LA(1);
 
-            if ( (LA153_0==44) ) {
-                alt153=1;
+            if ( (LA156_0==44) ) {
+                alt156=1;
             }
-            switch (alt153) {
+            switch (alt156) {
                 case 1 :
-                    // InternalRoom.g:15227:2: rule__SimpleState__Group_3__0
+                    // InternalRoom.g:15456:2: rule__SimpleState__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3__0();
@@ -42477,16 +43136,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__0"
-    // InternalRoom.g:15245:1: rule__SimpleState__Group_3__0 : rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ;
+    // InternalRoom.g:15474:1: rule__SimpleState__Group_3__0 : rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ;
     public final void rule__SimpleState__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15249:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 )
-            // InternalRoom.g:15250:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1
+            // InternalRoom.g:15478:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 )
+            // InternalRoom.g:15479:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__SimpleState__Group_3__0__Impl();
 
             state._fsp--;
@@ -42515,17 +43174,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__0__Impl"
-    // InternalRoom.g:15257:1: rule__SimpleState__Group_3__0__Impl : ( '{' ) ;
+    // InternalRoom.g:15486:1: rule__SimpleState__Group_3__0__Impl : ( '{' ) ;
     public final void rule__SimpleState__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15261:1: ( ( '{' ) )
-            // InternalRoom.g:15262:1: ( '{' )
+            // InternalRoom.g:15490:1: ( ( '{' ) )
+            // InternalRoom.g:15491:1: ( '{' )
             {
-            // InternalRoom.g:15262:1: ( '{' )
-            // InternalRoom.g:15263:1: '{'
+            // InternalRoom.g:15491:1: ( '{' )
+            // InternalRoom.g:15492:1: '{'
             {
              before(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); 
             match(input,44,FOLLOW_2); 
@@ -42552,16 +43211,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__1"
-    // InternalRoom.g:15276:1: rule__SimpleState__Group_3__1 : rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ;
+    // InternalRoom.g:15505:1: rule__SimpleState__Group_3__1 : rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ;
     public final void rule__SimpleState__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15280:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 )
-            // InternalRoom.g:15281:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2
+            // InternalRoom.g:15509:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 )
+            // InternalRoom.g:15510:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__SimpleState__Group_3__1__Impl();
 
             state._fsp--;
@@ -42590,29 +43249,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__1__Impl"
-    // InternalRoom.g:15288:1: rule__SimpleState__Group_3__1__Impl : ( ( rule__SimpleState__Group_3_1__0 )? ) ;
+    // InternalRoom.g:15517:1: rule__SimpleState__Group_3__1__Impl : ( ( rule__SimpleState__Group_3_1__0 )? ) ;
     public final void rule__SimpleState__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15292:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) )
-            // InternalRoom.g:15293:1: ( ( rule__SimpleState__Group_3_1__0 )? )
+            // InternalRoom.g:15521:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) )
+            // InternalRoom.g:15522:1: ( ( rule__SimpleState__Group_3_1__0 )? )
             {
-            // InternalRoom.g:15293:1: ( ( rule__SimpleState__Group_3_1__0 )? )
-            // InternalRoom.g:15294:1: ( rule__SimpleState__Group_3_1__0 )?
+            // InternalRoom.g:15522:1: ( ( rule__SimpleState__Group_3_1__0 )? )
+            // InternalRoom.g:15523:1: ( rule__SimpleState__Group_3_1__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_1()); 
-            // InternalRoom.g:15295:1: ( rule__SimpleState__Group_3_1__0 )?
-            int alt154=2;
-            int LA154_0 = input.LA(1);
+            // InternalRoom.g:15524:1: ( rule__SimpleState__Group_3_1__0 )?
+            int alt157=2;
+            int LA157_0 = input.LA(1);
 
-            if ( (LA154_0==96) ) {
-                alt154=1;
+            if ( (LA157_0==96) ) {
+                alt157=1;
             }
-            switch (alt154) {
+            switch (alt157) {
                 case 1 :
-                    // InternalRoom.g:15295:2: rule__SimpleState__Group_3_1__0
+                    // InternalRoom.g:15524:2: rule__SimpleState__Group_3_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_1__0();
@@ -42648,16 +43307,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__2"
-    // InternalRoom.g:15305:1: rule__SimpleState__Group_3__2 : rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ;
+    // InternalRoom.g:15534:1: rule__SimpleState__Group_3__2 : rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ;
     public final void rule__SimpleState__Group_3__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15309:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 )
-            // InternalRoom.g:15310:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3
+            // InternalRoom.g:15538:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 )
+            // InternalRoom.g:15539:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__SimpleState__Group_3__2__Impl();
 
             state._fsp--;
@@ -42686,29 +43345,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__2__Impl"
-    // InternalRoom.g:15317:1: rule__SimpleState__Group_3__2__Impl : ( ( rule__SimpleState__Group_3_2__0 )? ) ;
+    // InternalRoom.g:15546:1: rule__SimpleState__Group_3__2__Impl : ( ( rule__SimpleState__Group_3_2__0 )? ) ;
     public final void rule__SimpleState__Group_3__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15321:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) )
-            // InternalRoom.g:15322:1: ( ( rule__SimpleState__Group_3_2__0 )? )
+            // InternalRoom.g:15550:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) )
+            // InternalRoom.g:15551:1: ( ( rule__SimpleState__Group_3_2__0 )? )
             {
-            // InternalRoom.g:15322:1: ( ( rule__SimpleState__Group_3_2__0 )? )
-            // InternalRoom.g:15323:1: ( rule__SimpleState__Group_3_2__0 )?
+            // InternalRoom.g:15551:1: ( ( rule__SimpleState__Group_3_2__0 )? )
+            // InternalRoom.g:15552:1: ( rule__SimpleState__Group_3_2__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_2()); 
-            // InternalRoom.g:15324:1: ( rule__SimpleState__Group_3_2__0 )?
-            int alt155=2;
-            int LA155_0 = input.LA(1);
+            // InternalRoom.g:15553:1: ( rule__SimpleState__Group_3_2__0 )?
+            int alt158=2;
+            int LA158_0 = input.LA(1);
 
-            if ( (LA155_0==97) ) {
-                alt155=1;
+            if ( (LA158_0==97) ) {
+                alt158=1;
             }
-            switch (alt155) {
+            switch (alt158) {
                 case 1 :
-                    // InternalRoom.g:15324:2: rule__SimpleState__Group_3_2__0
+                    // InternalRoom.g:15553:2: rule__SimpleState__Group_3_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_2__0();
@@ -42744,16 +43403,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__3"
-    // InternalRoom.g:15334:1: rule__SimpleState__Group_3__3 : rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ;
+    // InternalRoom.g:15563:1: rule__SimpleState__Group_3__3 : rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ;
     public final void rule__SimpleState__Group_3__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15338:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 )
-            // InternalRoom.g:15339:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4
+            // InternalRoom.g:15567:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 )
+            // InternalRoom.g:15568:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__SimpleState__Group_3__3__Impl();
 
             state._fsp--;
@@ -42782,29 +43441,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__3__Impl"
-    // InternalRoom.g:15346:1: rule__SimpleState__Group_3__3__Impl : ( ( rule__SimpleState__Group_3_3__0 )? ) ;
+    // InternalRoom.g:15575:1: rule__SimpleState__Group_3__3__Impl : ( ( rule__SimpleState__Group_3_3__0 )? ) ;
     public final void rule__SimpleState__Group_3__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15350:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) )
-            // InternalRoom.g:15351:1: ( ( rule__SimpleState__Group_3_3__0 )? )
+            // InternalRoom.g:15579:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) )
+            // InternalRoom.g:15580:1: ( ( rule__SimpleState__Group_3_3__0 )? )
             {
-            // InternalRoom.g:15351:1: ( ( rule__SimpleState__Group_3_3__0 )? )
-            // InternalRoom.g:15352:1: ( rule__SimpleState__Group_3_3__0 )?
+            // InternalRoom.g:15580:1: ( ( rule__SimpleState__Group_3_3__0 )? )
+            // InternalRoom.g:15581:1: ( rule__SimpleState__Group_3_3__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_3()); 
-            // InternalRoom.g:15353:1: ( rule__SimpleState__Group_3_3__0 )?
-            int alt156=2;
-            int LA156_0 = input.LA(1);
+            // InternalRoom.g:15582:1: ( rule__SimpleState__Group_3_3__0 )?
+            int alt159=2;
+            int LA159_0 = input.LA(1);
 
-            if ( (LA156_0==98) ) {
-                alt156=1;
+            if ( (LA159_0==98) ) {
+                alt159=1;
             }
-            switch (alt156) {
+            switch (alt159) {
                 case 1 :
-                    // InternalRoom.g:15353:2: rule__SimpleState__Group_3_3__0
+                    // InternalRoom.g:15582:2: rule__SimpleState__Group_3_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_3__0();
@@ -42840,16 +43499,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__4"
-    // InternalRoom.g:15363:1: rule__SimpleState__Group_3__4 : rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ;
+    // InternalRoom.g:15592:1: rule__SimpleState__Group_3__4 : rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ;
     public final void rule__SimpleState__Group_3__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15367:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 )
-            // InternalRoom.g:15368:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5
+            // InternalRoom.g:15596:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 )
+            // InternalRoom.g:15597:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__SimpleState__Group_3__4__Impl();
 
             state._fsp--;
@@ -42878,29 +43537,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__4__Impl"
-    // InternalRoom.g:15375:1: rule__SimpleState__Group_3__4__Impl : ( ( rule__SimpleState__Group_3_4__0 )? ) ;
+    // InternalRoom.g:15604:1: rule__SimpleState__Group_3__4__Impl : ( ( rule__SimpleState__Group_3_4__0 )? ) ;
     public final void rule__SimpleState__Group_3__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15379:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) )
-            // InternalRoom.g:15380:1: ( ( rule__SimpleState__Group_3_4__0 )? )
+            // InternalRoom.g:15608:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) )
+            // InternalRoom.g:15609:1: ( ( rule__SimpleState__Group_3_4__0 )? )
             {
-            // InternalRoom.g:15380:1: ( ( rule__SimpleState__Group_3_4__0 )? )
-            // InternalRoom.g:15381:1: ( rule__SimpleState__Group_3_4__0 )?
+            // InternalRoom.g:15609:1: ( ( rule__SimpleState__Group_3_4__0 )? )
+            // InternalRoom.g:15610:1: ( rule__SimpleState__Group_3_4__0 )?
             {
              before(grammarAccess.getSimpleStateAccess().getGroup_3_4()); 
-            // InternalRoom.g:15382:1: ( rule__SimpleState__Group_3_4__0 )?
-            int alt157=2;
-            int LA157_0 = input.LA(1);
+            // InternalRoom.g:15611:1: ( rule__SimpleState__Group_3_4__0 )?
+            int alt160=2;
+            int LA160_0 = input.LA(1);
 
-            if ( (LA157_0==99) ) {
-                alt157=1;
+            if ( (LA160_0==99) ) {
+                alt160=1;
             }
-            switch (alt157) {
+            switch (alt160) {
                 case 1 :
-                    // InternalRoom.g:15382:2: rule__SimpleState__Group_3_4__0
+                    // InternalRoom.g:15611:2: rule__SimpleState__Group_3_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_4__0();
@@ -42936,14 +43595,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__5"
-    // InternalRoom.g:15392:1: rule__SimpleState__Group_3__5 : rule__SimpleState__Group_3__5__Impl ;
+    // InternalRoom.g:15621:1: rule__SimpleState__Group_3__5 : rule__SimpleState__Group_3__5__Impl ;
     public final void rule__SimpleState__Group_3__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15396:1: ( rule__SimpleState__Group_3__5__Impl )
-            // InternalRoom.g:15397:2: rule__SimpleState__Group_3__5__Impl
+            // InternalRoom.g:15625:1: ( rule__SimpleState__Group_3__5__Impl )
+            // InternalRoom.g:15626:2: rule__SimpleState__Group_3__5__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3__5__Impl();
@@ -42969,17 +43628,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3__5__Impl"
-    // InternalRoom.g:15403:1: rule__SimpleState__Group_3__5__Impl : ( '}' ) ;
+    // InternalRoom.g:15632:1: rule__SimpleState__Group_3__5__Impl : ( '}' ) ;
     public final void rule__SimpleState__Group_3__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15407:1: ( ( '}' ) )
-            // InternalRoom.g:15408:1: ( '}' )
+            // InternalRoom.g:15636:1: ( ( '}' ) )
+            // InternalRoom.g:15637:1: ( '}' )
             {
-            // InternalRoom.g:15408:1: ( '}' )
-            // InternalRoom.g:15409:1: '}'
+            // InternalRoom.g:15637:1: ( '}' )
+            // InternalRoom.g:15638:1: '}'
             {
              before(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); 
             match(input,45,FOLLOW_2); 
@@ -43006,14 +43665,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__0"
-    // InternalRoom.g:15434:1: rule__SimpleState__Group_3_1__0 : rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ;
+    // InternalRoom.g:15663:1: rule__SimpleState__Group_3_1__0 : rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ;
     public final void rule__SimpleState__Group_3_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15438:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 )
-            // InternalRoom.g:15439:2: rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1
+            // InternalRoom.g:15667:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 )
+            // InternalRoom.g:15668:2: rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1
             {
             pushFollow(FOLLOW_27);
             rule__SimpleState__Group_3_1__0__Impl();
@@ -43044,17 +43703,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__0__Impl"
-    // InternalRoom.g:15446:1: rule__SimpleState__Group_3_1__0__Impl : ( 'entry' ) ;
+    // InternalRoom.g:15675:1: rule__SimpleState__Group_3_1__0__Impl : ( 'entry' ) ;
     public final void rule__SimpleState__Group_3_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15450:1: ( ( 'entry' ) )
-            // InternalRoom.g:15451:1: ( 'entry' )
+            // InternalRoom.g:15679:1: ( ( 'entry' ) )
+            // InternalRoom.g:15680:1: ( 'entry' )
             {
-            // InternalRoom.g:15451:1: ( 'entry' )
-            // InternalRoom.g:15452:1: 'entry'
+            // InternalRoom.g:15680:1: ( 'entry' )
+            // InternalRoom.g:15681:1: 'entry'
             {
              before(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); 
             match(input,96,FOLLOW_2); 
@@ -43081,14 +43740,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__1"
-    // InternalRoom.g:15465:1: rule__SimpleState__Group_3_1__1 : rule__SimpleState__Group_3_1__1__Impl ;
+    // InternalRoom.g:15694:1: rule__SimpleState__Group_3_1__1 : rule__SimpleState__Group_3_1__1__Impl ;
     public final void rule__SimpleState__Group_3_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15469:1: ( rule__SimpleState__Group_3_1__1__Impl )
-            // InternalRoom.g:15470:2: rule__SimpleState__Group_3_1__1__Impl
+            // InternalRoom.g:15698:1: ( rule__SimpleState__Group_3_1__1__Impl )
+            // InternalRoom.g:15699:2: rule__SimpleState__Group_3_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_1__1__Impl();
@@ -43114,21 +43773,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_1__1__Impl"
-    // InternalRoom.g:15476:1: rule__SimpleState__Group_3_1__1__Impl : ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ;
+    // InternalRoom.g:15705:1: rule__SimpleState__Group_3_1__1__Impl : ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ;
     public final void rule__SimpleState__Group_3_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15480:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) )
-            // InternalRoom.g:15481:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
+            // InternalRoom.g:15709:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) )
+            // InternalRoom.g:15710:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
             {
-            // InternalRoom.g:15481:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
-            // InternalRoom.g:15482:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
+            // InternalRoom.g:15710:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
+            // InternalRoom.g:15711:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); 
-            // InternalRoom.g:15483:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
-            // InternalRoom.g:15483:2: rule__SimpleState__EntryCodeAssignment_3_1_1
+            // InternalRoom.g:15712:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
+            // InternalRoom.g:15712:2: rule__SimpleState__EntryCodeAssignment_3_1_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__EntryCodeAssignment_3_1_1();
@@ -43161,14 +43820,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__0"
-    // InternalRoom.g:15497:1: rule__SimpleState__Group_3_2__0 : rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ;
+    // InternalRoom.g:15726:1: rule__SimpleState__Group_3_2__0 : rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ;
     public final void rule__SimpleState__Group_3_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15501:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 )
-            // InternalRoom.g:15502:2: rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1
+            // InternalRoom.g:15730:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 )
+            // InternalRoom.g:15731:2: rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1
             {
             pushFollow(FOLLOW_27);
             rule__SimpleState__Group_3_2__0__Impl();
@@ -43199,17 +43858,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__0__Impl"
-    // InternalRoom.g:15509:1: rule__SimpleState__Group_3_2__0__Impl : ( 'exit' ) ;
+    // InternalRoom.g:15738:1: rule__SimpleState__Group_3_2__0__Impl : ( 'exit' ) ;
     public final void rule__SimpleState__Group_3_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15513:1: ( ( 'exit' ) )
-            // InternalRoom.g:15514:1: ( 'exit' )
+            // InternalRoom.g:15742:1: ( ( 'exit' ) )
+            // InternalRoom.g:15743:1: ( 'exit' )
             {
-            // InternalRoom.g:15514:1: ( 'exit' )
-            // InternalRoom.g:15515:1: 'exit'
+            // InternalRoom.g:15743:1: ( 'exit' )
+            // InternalRoom.g:15744:1: 'exit'
             {
              before(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); 
             match(input,97,FOLLOW_2); 
@@ -43236,14 +43895,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__1"
-    // InternalRoom.g:15528:1: rule__SimpleState__Group_3_2__1 : rule__SimpleState__Group_3_2__1__Impl ;
+    // InternalRoom.g:15757:1: rule__SimpleState__Group_3_2__1 : rule__SimpleState__Group_3_2__1__Impl ;
     public final void rule__SimpleState__Group_3_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15532:1: ( rule__SimpleState__Group_3_2__1__Impl )
-            // InternalRoom.g:15533:2: rule__SimpleState__Group_3_2__1__Impl
+            // InternalRoom.g:15761:1: ( rule__SimpleState__Group_3_2__1__Impl )
+            // InternalRoom.g:15762:2: rule__SimpleState__Group_3_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_2__1__Impl();
@@ -43269,21 +43928,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_2__1__Impl"
-    // InternalRoom.g:15539:1: rule__SimpleState__Group_3_2__1__Impl : ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ;
+    // InternalRoom.g:15768:1: rule__SimpleState__Group_3_2__1__Impl : ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ;
     public final void rule__SimpleState__Group_3_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15543:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) )
-            // InternalRoom.g:15544:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
+            // InternalRoom.g:15772:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) )
+            // InternalRoom.g:15773:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
             {
-            // InternalRoom.g:15544:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
-            // InternalRoom.g:15545:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
+            // InternalRoom.g:15773:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
+            // InternalRoom.g:15774:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); 
-            // InternalRoom.g:15546:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
-            // InternalRoom.g:15546:2: rule__SimpleState__ExitCodeAssignment_3_2_1
+            // InternalRoom.g:15775:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
+            // InternalRoom.g:15775:2: rule__SimpleState__ExitCodeAssignment_3_2_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__ExitCodeAssignment_3_2_1();
@@ -43316,14 +43975,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__0"
-    // InternalRoom.g:15560:1: rule__SimpleState__Group_3_3__0 : rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ;
+    // InternalRoom.g:15789:1: rule__SimpleState__Group_3_3__0 : rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ;
     public final void rule__SimpleState__Group_3_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15564:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 )
-            // InternalRoom.g:15565:2: rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1
+            // InternalRoom.g:15793:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 )
+            // InternalRoom.g:15794:2: rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1
             {
             pushFollow(FOLLOW_27);
             rule__SimpleState__Group_3_3__0__Impl();
@@ -43354,17 +44013,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__0__Impl"
-    // InternalRoom.g:15572:1: rule__SimpleState__Group_3_3__0__Impl : ( 'do' ) ;
+    // InternalRoom.g:15801:1: rule__SimpleState__Group_3_3__0__Impl : ( 'do' ) ;
     public final void rule__SimpleState__Group_3_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15576:1: ( ( 'do' ) )
-            // InternalRoom.g:15577:1: ( 'do' )
+            // InternalRoom.g:15805:1: ( ( 'do' ) )
+            // InternalRoom.g:15806:1: ( 'do' )
             {
-            // InternalRoom.g:15577:1: ( 'do' )
-            // InternalRoom.g:15578:1: 'do'
+            // InternalRoom.g:15806:1: ( 'do' )
+            // InternalRoom.g:15807:1: 'do'
             {
              before(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); 
             match(input,98,FOLLOW_2); 
@@ -43391,14 +44050,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__1"
-    // InternalRoom.g:15591:1: rule__SimpleState__Group_3_3__1 : rule__SimpleState__Group_3_3__1__Impl ;
+    // InternalRoom.g:15820:1: rule__SimpleState__Group_3_3__1 : rule__SimpleState__Group_3_3__1__Impl ;
     public final void rule__SimpleState__Group_3_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15595:1: ( rule__SimpleState__Group_3_3__1__Impl )
-            // InternalRoom.g:15596:2: rule__SimpleState__Group_3_3__1__Impl
+            // InternalRoom.g:15824:1: ( rule__SimpleState__Group_3_3__1__Impl )
+            // InternalRoom.g:15825:2: rule__SimpleState__Group_3_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_3__1__Impl();
@@ -43424,21 +44083,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_3__1__Impl"
-    // InternalRoom.g:15602:1: rule__SimpleState__Group_3_3__1__Impl : ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ;
+    // InternalRoom.g:15831:1: rule__SimpleState__Group_3_3__1__Impl : ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ;
     public final void rule__SimpleState__Group_3_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15606:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) )
-            // InternalRoom.g:15607:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
+            // InternalRoom.g:15835:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) )
+            // InternalRoom.g:15836:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
             {
-            // InternalRoom.g:15607:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
-            // InternalRoom.g:15608:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
+            // InternalRoom.g:15836:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
+            // InternalRoom.g:15837:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); 
-            // InternalRoom.g:15609:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
-            // InternalRoom.g:15609:2: rule__SimpleState__DoCodeAssignment_3_3_1
+            // InternalRoom.g:15838:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
+            // InternalRoom.g:15838:2: rule__SimpleState__DoCodeAssignment_3_3_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__DoCodeAssignment_3_3_1();
@@ -43471,14 +44130,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__0"
-    // InternalRoom.g:15623:1: rule__SimpleState__Group_3_4__0 : rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ;
+    // InternalRoom.g:15852:1: rule__SimpleState__Group_3_4__0 : rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ;
     public final void rule__SimpleState__Group_3_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15627:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 )
-            // InternalRoom.g:15628:2: rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1
+            // InternalRoom.g:15856:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 )
+            // InternalRoom.g:15857:2: rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1
             {
             pushFollow(FOLLOW_40);
             rule__SimpleState__Group_3_4__0__Impl();
@@ -43509,17 +44168,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__0__Impl"
-    // InternalRoom.g:15635:1: rule__SimpleState__Group_3_4__0__Impl : ( 'subgraph' ) ;
+    // InternalRoom.g:15864:1: rule__SimpleState__Group_3_4__0__Impl : ( 'subgraph' ) ;
     public final void rule__SimpleState__Group_3_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15639:1: ( ( 'subgraph' ) )
-            // InternalRoom.g:15640:1: ( 'subgraph' )
+            // InternalRoom.g:15868:1: ( ( 'subgraph' ) )
+            // InternalRoom.g:15869:1: ( 'subgraph' )
             {
-            // InternalRoom.g:15640:1: ( 'subgraph' )
-            // InternalRoom.g:15641:1: 'subgraph'
+            // InternalRoom.g:15869:1: ( 'subgraph' )
+            // InternalRoom.g:15870:1: 'subgraph'
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); 
             match(input,99,FOLLOW_2); 
@@ -43546,14 +44205,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__1"
-    // InternalRoom.g:15654:1: rule__SimpleState__Group_3_4__1 : rule__SimpleState__Group_3_4__1__Impl ;
+    // InternalRoom.g:15883:1: rule__SimpleState__Group_3_4__1 : rule__SimpleState__Group_3_4__1__Impl ;
     public final void rule__SimpleState__Group_3_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15658:1: ( rule__SimpleState__Group_3_4__1__Impl )
-            // InternalRoom.g:15659:2: rule__SimpleState__Group_3_4__1__Impl
+            // InternalRoom.g:15887:1: ( rule__SimpleState__Group_3_4__1__Impl )
+            // InternalRoom.g:15888:2: rule__SimpleState__Group_3_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_4__1__Impl();
@@ -43579,21 +44238,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__Group_3_4__1__Impl"
-    // InternalRoom.g:15665:1: rule__SimpleState__Group_3_4__1__Impl : ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ;
+    // InternalRoom.g:15894:1: rule__SimpleState__Group_3_4__1__Impl : ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ;
     public final void rule__SimpleState__Group_3_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15669:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) )
-            // InternalRoom.g:15670:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
+            // InternalRoom.g:15898:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) )
+            // InternalRoom.g:15899:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
             {
-            // InternalRoom.g:15670:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
-            // InternalRoom.g:15671:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
+            // InternalRoom.g:15899:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
+            // InternalRoom.g:15900:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); 
-            // InternalRoom.g:15672:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
-            // InternalRoom.g:15672:2: rule__SimpleState__SubgraphAssignment_3_4_1
+            // InternalRoom.g:15901:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
+            // InternalRoom.g:15901:2: rule__SimpleState__SubgraphAssignment_3_4_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__SubgraphAssignment_3_4_1();
@@ -43626,14 +44285,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__0"
-    // InternalRoom.g:15686:1: rule__RefinedState__Group__0 : rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ;
+    // InternalRoom.g:15915:1: rule__RefinedState__Group__0 : rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ;
     public final void rule__RefinedState__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15690:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 )
-            // InternalRoom.g:15691:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1
+            // InternalRoom.g:15919:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 )
+            // InternalRoom.g:15920:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefinedState__Group__0__Impl();
@@ -43664,17 +44323,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__0__Impl"
-    // InternalRoom.g:15698:1: rule__RefinedState__Group__0__Impl : ( 'RefinedState' ) ;
+    // InternalRoom.g:15927:1: rule__RefinedState__Group__0__Impl : ( 'RefinedState' ) ;
     public final void rule__RefinedState__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15702:1: ( ( 'RefinedState' ) )
-            // InternalRoom.g:15703:1: ( 'RefinedState' )
+            // InternalRoom.g:15931:1: ( ( 'RefinedState' ) )
+            // InternalRoom.g:15932:1: ( 'RefinedState' )
             {
-            // InternalRoom.g:15703:1: ( 'RefinedState' )
-            // InternalRoom.g:15704:1: 'RefinedState'
+            // InternalRoom.g:15932:1: ( 'RefinedState' )
+            // InternalRoom.g:15933:1: 'RefinedState'
             {
              before(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); 
             match(input,100,FOLLOW_2); 
@@ -43701,14 +44360,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__1"
-    // InternalRoom.g:15717:1: rule__RefinedState__Group__1 : rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ;
+    // InternalRoom.g:15946:1: rule__RefinedState__Group__1 : rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ;
     public final void rule__RefinedState__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15721:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 )
-            // InternalRoom.g:15722:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2
+            // InternalRoom.g:15950:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 )
+            // InternalRoom.g:15951:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RefinedState__Group__1__Impl();
@@ -43739,21 +44398,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__1__Impl"
-    // InternalRoom.g:15729:1: rule__RefinedState__Group__1__Impl : ( ( rule__RefinedState__TargetAssignment_1 ) ) ;
+    // InternalRoom.g:15958:1: rule__RefinedState__Group__1__Impl : ( ( rule__RefinedState__TargetAssignment_1 ) ) ;
     public final void rule__RefinedState__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15733:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) )
-            // InternalRoom.g:15734:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
+            // InternalRoom.g:15962:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) )
+            // InternalRoom.g:15963:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
             {
-            // InternalRoom.g:15734:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
-            // InternalRoom.g:15735:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalRoom.g:15963:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
+            // InternalRoom.g:15964:1: ( rule__RefinedState__TargetAssignment_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); 
-            // InternalRoom.g:15736:1: ( rule__RefinedState__TargetAssignment_1 )
-            // InternalRoom.g:15736:2: rule__RefinedState__TargetAssignment_1
+            // InternalRoom.g:15965:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalRoom.g:15965:2: rule__RefinedState__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__TargetAssignment_1();
@@ -43786,14 +44445,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__2"
-    // InternalRoom.g:15746:1: rule__RefinedState__Group__2 : rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ;
+    // InternalRoom.g:15975:1: rule__RefinedState__Group__2 : rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ;
     public final void rule__RefinedState__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15750:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 )
-            // InternalRoom.g:15751:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3
+            // InternalRoom.g:15979:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 )
+            // InternalRoom.g:15980:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RefinedState__Group__2__Impl();
@@ -43824,29 +44483,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__2__Impl"
-    // InternalRoom.g:15758:1: rule__RefinedState__Group__2__Impl : ( ( rule__RefinedState__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:15987:1: rule__RefinedState__Group__2__Impl : ( ( rule__RefinedState__DocuAssignment_2 )? ) ;
     public final void rule__RefinedState__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15762:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) )
-            // InternalRoom.g:15763:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
+            // InternalRoom.g:15991:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) )
+            // InternalRoom.g:15992:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:15763:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
-            // InternalRoom.g:15764:1: ( rule__RefinedState__DocuAssignment_2 )?
+            // InternalRoom.g:15992:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
+            // InternalRoom.g:15993:1: ( rule__RefinedState__DocuAssignment_2 )?
             {
              before(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:15765:1: ( rule__RefinedState__DocuAssignment_2 )?
-            int alt158=2;
-            int LA158_0 = input.LA(1);
+            // InternalRoom.g:15994:1: ( rule__RefinedState__DocuAssignment_2 )?
+            int alt161=2;
+            int LA161_0 = input.LA(1);
 
-            if ( (LA158_0==62) ) {
-                alt158=1;
+            if ( (LA161_0==62) ) {
+                alt161=1;
             }
-            switch (alt158) {
+            switch (alt161) {
                 case 1 :
-                    // InternalRoom.g:15765:2: rule__RefinedState__DocuAssignment_2
+                    // InternalRoom.g:15994:2: rule__RefinedState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__DocuAssignment_2();
@@ -43882,16 +44541,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__3"
-    // InternalRoom.g:15775:1: rule__RefinedState__Group__3 : rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ;
+    // InternalRoom.g:16004:1: rule__RefinedState__Group__3 : rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ;
     public final void rule__RefinedState__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15779:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 )
-            // InternalRoom.g:15780:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4
+            // InternalRoom.g:16008:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 )
+            // InternalRoom.g:16009:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__RefinedState__Group__3__Impl();
 
             state._fsp--;
@@ -43920,17 +44579,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__3__Impl"
-    // InternalRoom.g:15787:1: rule__RefinedState__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:16016:1: rule__RefinedState__Group__3__Impl : ( '{' ) ;
     public final void rule__RefinedState__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15791:1: ( ( '{' ) )
-            // InternalRoom.g:15792:1: ( '{' )
+            // InternalRoom.g:16020:1: ( ( '{' ) )
+            // InternalRoom.g:16021:1: ( '{' )
             {
-            // InternalRoom.g:15792:1: ( '{' )
-            // InternalRoom.g:15793:1: '{'
+            // InternalRoom.g:16021:1: ( '{' )
+            // InternalRoom.g:16022:1: '{'
             {
              before(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -43957,16 +44616,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__4"
-    // InternalRoom.g:15806:1: rule__RefinedState__Group__4 : rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ;
+    // InternalRoom.g:16035:1: rule__RefinedState__Group__4 : rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ;
     public final void rule__RefinedState__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15810:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 )
-            // InternalRoom.g:15811:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5
+            // InternalRoom.g:16039:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 )
+            // InternalRoom.g:16040:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__RefinedState__Group__4__Impl();
 
             state._fsp--;
@@ -43995,29 +44654,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__4__Impl"
-    // InternalRoom.g:15818:1: rule__RefinedState__Group__4__Impl : ( ( rule__RefinedState__Group_4__0 )? ) ;
+    // InternalRoom.g:16047:1: rule__RefinedState__Group__4__Impl : ( ( rule__RefinedState__Group_4__0 )? ) ;
     public final void rule__RefinedState__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15822:1: ( ( ( rule__RefinedState__Group_4__0 )? ) )
-            // InternalRoom.g:15823:1: ( ( rule__RefinedState__Group_4__0 )? )
+            // InternalRoom.g:16051:1: ( ( ( rule__RefinedState__Group_4__0 )? ) )
+            // InternalRoom.g:16052:1: ( ( rule__RefinedState__Group_4__0 )? )
             {
-            // InternalRoom.g:15823:1: ( ( rule__RefinedState__Group_4__0 )? )
-            // InternalRoom.g:15824:1: ( rule__RefinedState__Group_4__0 )?
+            // InternalRoom.g:16052:1: ( ( rule__RefinedState__Group_4__0 )? )
+            // InternalRoom.g:16053:1: ( rule__RefinedState__Group_4__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_4()); 
-            // InternalRoom.g:15825:1: ( rule__RefinedState__Group_4__0 )?
-            int alt159=2;
-            int LA159_0 = input.LA(1);
+            // InternalRoom.g:16054:1: ( rule__RefinedState__Group_4__0 )?
+            int alt162=2;
+            int LA162_0 = input.LA(1);
 
-            if ( (LA159_0==96) ) {
-                alt159=1;
+            if ( (LA162_0==96) ) {
+                alt162=1;
             }
-            switch (alt159) {
+            switch (alt162) {
                 case 1 :
-                    // InternalRoom.g:15825:2: rule__RefinedState__Group_4__0
+                    // InternalRoom.g:16054:2: rule__RefinedState__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_4__0();
@@ -44053,16 +44712,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__5"
-    // InternalRoom.g:15835:1: rule__RefinedState__Group__5 : rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ;
+    // InternalRoom.g:16064:1: rule__RefinedState__Group__5 : rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ;
     public final void rule__RefinedState__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15839:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 )
-            // InternalRoom.g:15840:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6
+            // InternalRoom.g:16068:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 )
+            // InternalRoom.g:16069:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__RefinedState__Group__5__Impl();
 
             state._fsp--;
@@ -44091,29 +44750,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__5__Impl"
-    // InternalRoom.g:15847:1: rule__RefinedState__Group__5__Impl : ( ( rule__RefinedState__Group_5__0 )? ) ;
+    // InternalRoom.g:16076:1: rule__RefinedState__Group__5__Impl : ( ( rule__RefinedState__Group_5__0 )? ) ;
     public final void rule__RefinedState__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15851:1: ( ( ( rule__RefinedState__Group_5__0 )? ) )
-            // InternalRoom.g:15852:1: ( ( rule__RefinedState__Group_5__0 )? )
+            // InternalRoom.g:16080:1: ( ( ( rule__RefinedState__Group_5__0 )? ) )
+            // InternalRoom.g:16081:1: ( ( rule__RefinedState__Group_5__0 )? )
             {
-            // InternalRoom.g:15852:1: ( ( rule__RefinedState__Group_5__0 )? )
-            // InternalRoom.g:15853:1: ( rule__RefinedState__Group_5__0 )?
+            // InternalRoom.g:16081:1: ( ( rule__RefinedState__Group_5__0 )? )
+            // InternalRoom.g:16082:1: ( rule__RefinedState__Group_5__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_5()); 
-            // InternalRoom.g:15854:1: ( rule__RefinedState__Group_5__0 )?
-            int alt160=2;
-            int LA160_0 = input.LA(1);
+            // InternalRoom.g:16083:1: ( rule__RefinedState__Group_5__0 )?
+            int alt163=2;
+            int LA163_0 = input.LA(1);
 
-            if ( (LA160_0==97) ) {
-                alt160=1;
+            if ( (LA163_0==97) ) {
+                alt163=1;
             }
-            switch (alt160) {
+            switch (alt163) {
                 case 1 :
-                    // InternalRoom.g:15854:2: rule__RefinedState__Group_5__0
+                    // InternalRoom.g:16083:2: rule__RefinedState__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_5__0();
@@ -44149,16 +44808,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__6"
-    // InternalRoom.g:15864:1: rule__RefinedState__Group__6 : rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ;
+    // InternalRoom.g:16093:1: rule__RefinedState__Group__6 : rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ;
     public final void rule__RefinedState__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15868:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 )
-            // InternalRoom.g:15869:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7
+            // InternalRoom.g:16097:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 )
+            // InternalRoom.g:16098:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__RefinedState__Group__6__Impl();
 
             state._fsp--;
@@ -44187,29 +44846,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__6__Impl"
-    // InternalRoom.g:15876:1: rule__RefinedState__Group__6__Impl : ( ( rule__RefinedState__Group_6__0 )? ) ;
+    // InternalRoom.g:16105:1: rule__RefinedState__Group__6__Impl : ( ( rule__RefinedState__Group_6__0 )? ) ;
     public final void rule__RefinedState__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15880:1: ( ( ( rule__RefinedState__Group_6__0 )? ) )
-            // InternalRoom.g:15881:1: ( ( rule__RefinedState__Group_6__0 )? )
+            // InternalRoom.g:16109:1: ( ( ( rule__RefinedState__Group_6__0 )? ) )
+            // InternalRoom.g:16110:1: ( ( rule__RefinedState__Group_6__0 )? )
             {
-            // InternalRoom.g:15881:1: ( ( rule__RefinedState__Group_6__0 )? )
-            // InternalRoom.g:15882:1: ( rule__RefinedState__Group_6__0 )?
+            // InternalRoom.g:16110:1: ( ( rule__RefinedState__Group_6__0 )? )
+            // InternalRoom.g:16111:1: ( rule__RefinedState__Group_6__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_6()); 
-            // InternalRoom.g:15883:1: ( rule__RefinedState__Group_6__0 )?
-            int alt161=2;
-            int LA161_0 = input.LA(1);
+            // InternalRoom.g:16112:1: ( rule__RefinedState__Group_6__0 )?
+            int alt164=2;
+            int LA164_0 = input.LA(1);
 
-            if ( (LA161_0==98) ) {
-                alt161=1;
+            if ( (LA164_0==98) ) {
+                alt164=1;
             }
-            switch (alt161) {
+            switch (alt164) {
                 case 1 :
-                    // InternalRoom.g:15883:2: rule__RefinedState__Group_6__0
+                    // InternalRoom.g:16112:2: rule__RefinedState__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_6__0();
@@ -44245,16 +44904,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__7"
-    // InternalRoom.g:15893:1: rule__RefinedState__Group__7 : rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ;
+    // InternalRoom.g:16122:1: rule__RefinedState__Group__7 : rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ;
     public final void rule__RefinedState__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15897:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 )
-            // InternalRoom.g:15898:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8
+            // InternalRoom.g:16126:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 )
+            // InternalRoom.g:16127:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8
             {
-            pushFollow(FOLLOW_81);
+            pushFollow(FOLLOW_82);
             rule__RefinedState__Group__7__Impl();
 
             state._fsp--;
@@ -44283,29 +44942,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__7__Impl"
-    // InternalRoom.g:15905:1: rule__RefinedState__Group__7__Impl : ( ( rule__RefinedState__Group_7__0 )? ) ;
+    // InternalRoom.g:16134:1: rule__RefinedState__Group__7__Impl : ( ( rule__RefinedState__Group_7__0 )? ) ;
     public final void rule__RefinedState__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15909:1: ( ( ( rule__RefinedState__Group_7__0 )? ) )
-            // InternalRoom.g:15910:1: ( ( rule__RefinedState__Group_7__0 )? )
+            // InternalRoom.g:16138:1: ( ( ( rule__RefinedState__Group_7__0 )? ) )
+            // InternalRoom.g:16139:1: ( ( rule__RefinedState__Group_7__0 )? )
             {
-            // InternalRoom.g:15910:1: ( ( rule__RefinedState__Group_7__0 )? )
-            // InternalRoom.g:15911:1: ( rule__RefinedState__Group_7__0 )?
+            // InternalRoom.g:16139:1: ( ( rule__RefinedState__Group_7__0 )? )
+            // InternalRoom.g:16140:1: ( rule__RefinedState__Group_7__0 )?
             {
              before(grammarAccess.getRefinedStateAccess().getGroup_7()); 
-            // InternalRoom.g:15912:1: ( rule__RefinedState__Group_7__0 )?
-            int alt162=2;
-            int LA162_0 = input.LA(1);
+            // InternalRoom.g:16141:1: ( rule__RefinedState__Group_7__0 )?
+            int alt165=2;
+            int LA165_0 = input.LA(1);
 
-            if ( (LA162_0==99) ) {
-                alt162=1;
+            if ( (LA165_0==99) ) {
+                alt165=1;
             }
-            switch (alt162) {
+            switch (alt165) {
                 case 1 :
-                    // InternalRoom.g:15912:2: rule__RefinedState__Group_7__0
+                    // InternalRoom.g:16141:2: rule__RefinedState__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_7__0();
@@ -44341,14 +45000,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__8"
-    // InternalRoom.g:15922:1: rule__RefinedState__Group__8 : rule__RefinedState__Group__8__Impl ;
+    // InternalRoom.g:16151:1: rule__RefinedState__Group__8 : rule__RefinedState__Group__8__Impl ;
     public final void rule__RefinedState__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15926:1: ( rule__RefinedState__Group__8__Impl )
-            // InternalRoom.g:15927:2: rule__RefinedState__Group__8__Impl
+            // InternalRoom.g:16155:1: ( rule__RefinedState__Group__8__Impl )
+            // InternalRoom.g:16156:2: rule__RefinedState__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group__8__Impl();
@@ -44374,17 +45033,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__8__Impl"
-    // InternalRoom.g:15933:1: rule__RefinedState__Group__8__Impl : ( '}' ) ;
+    // InternalRoom.g:16162:1: rule__RefinedState__Group__8__Impl : ( '}' ) ;
     public final void rule__RefinedState__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15937:1: ( ( '}' ) )
-            // InternalRoom.g:15938:1: ( '}' )
+            // InternalRoom.g:16166:1: ( ( '}' ) )
+            // InternalRoom.g:16167:1: ( '}' )
             {
-            // InternalRoom.g:15938:1: ( '}' )
-            // InternalRoom.g:15939:1: '}'
+            // InternalRoom.g:16167:1: ( '}' )
+            // InternalRoom.g:16168:1: '}'
             {
              before(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); 
             match(input,45,FOLLOW_2); 
@@ -44411,14 +45070,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__0"
-    // InternalRoom.g:15970:1: rule__RefinedState__Group_4__0 : rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ;
+    // InternalRoom.g:16199:1: rule__RefinedState__Group_4__0 : rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ;
     public final void rule__RefinedState__Group_4__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15974:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 )
-            // InternalRoom.g:15975:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1
+            // InternalRoom.g:16203:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 )
+            // InternalRoom.g:16204:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_4__0__Impl();
@@ -44449,17 +45108,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__0__Impl"
-    // InternalRoom.g:15982:1: rule__RefinedState__Group_4__0__Impl : ( 'entry' ) ;
+    // InternalRoom.g:16211:1: rule__RefinedState__Group_4__0__Impl : ( 'entry' ) ;
     public final void rule__RefinedState__Group_4__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:15986:1: ( ( 'entry' ) )
-            // InternalRoom.g:15987:1: ( 'entry' )
+            // InternalRoom.g:16215:1: ( ( 'entry' ) )
+            // InternalRoom.g:16216:1: ( 'entry' )
             {
-            // InternalRoom.g:15987:1: ( 'entry' )
-            // InternalRoom.g:15988:1: 'entry'
+            // InternalRoom.g:16216:1: ( 'entry' )
+            // InternalRoom.g:16217:1: 'entry'
             {
              before(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); 
             match(input,96,FOLLOW_2); 
@@ -44486,14 +45145,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__1"
-    // InternalRoom.g:16001:1: rule__RefinedState__Group_4__1 : rule__RefinedState__Group_4__1__Impl ;
+    // InternalRoom.g:16230:1: rule__RefinedState__Group_4__1 : rule__RefinedState__Group_4__1__Impl ;
     public final void rule__RefinedState__Group_4__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16005:1: ( rule__RefinedState__Group_4__1__Impl )
-            // InternalRoom.g:16006:2: rule__RefinedState__Group_4__1__Impl
+            // InternalRoom.g:16234:1: ( rule__RefinedState__Group_4__1__Impl )
+            // InternalRoom.g:16235:2: rule__RefinedState__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_4__1__Impl();
@@ -44519,21 +45178,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_4__1__Impl"
-    // InternalRoom.g:16012:1: rule__RefinedState__Group_4__1__Impl : ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ;
+    // InternalRoom.g:16241:1: rule__RefinedState__Group_4__1__Impl : ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ;
     public final void rule__RefinedState__Group_4__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16016:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) )
-            // InternalRoom.g:16017:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
+            // InternalRoom.g:16245:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) )
+            // InternalRoom.g:16246:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
             {
-            // InternalRoom.g:16017:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
-            // InternalRoom.g:16018:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
+            // InternalRoom.g:16246:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
+            // InternalRoom.g:16247:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); 
-            // InternalRoom.g:16019:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
-            // InternalRoom.g:16019:2: rule__RefinedState__EntryCodeAssignment_4_1
+            // InternalRoom.g:16248:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
+            // InternalRoom.g:16248:2: rule__RefinedState__EntryCodeAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__EntryCodeAssignment_4_1();
@@ -44566,14 +45225,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__0"
-    // InternalRoom.g:16033:1: rule__RefinedState__Group_5__0 : rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ;
+    // InternalRoom.g:16262:1: rule__RefinedState__Group_5__0 : rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ;
     public final void rule__RefinedState__Group_5__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16037:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 )
-            // InternalRoom.g:16038:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1
+            // InternalRoom.g:16266:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 )
+            // InternalRoom.g:16267:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_5__0__Impl();
@@ -44604,17 +45263,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__0__Impl"
-    // InternalRoom.g:16045:1: rule__RefinedState__Group_5__0__Impl : ( 'exit' ) ;
+    // InternalRoom.g:16274:1: rule__RefinedState__Group_5__0__Impl : ( 'exit' ) ;
     public final void rule__RefinedState__Group_5__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16049:1: ( ( 'exit' ) )
-            // InternalRoom.g:16050:1: ( 'exit' )
+            // InternalRoom.g:16278:1: ( ( 'exit' ) )
+            // InternalRoom.g:16279:1: ( 'exit' )
             {
-            // InternalRoom.g:16050:1: ( 'exit' )
-            // InternalRoom.g:16051:1: 'exit'
+            // InternalRoom.g:16279:1: ( 'exit' )
+            // InternalRoom.g:16280:1: 'exit'
             {
              before(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); 
             match(input,97,FOLLOW_2); 
@@ -44641,14 +45300,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__1"
-    // InternalRoom.g:16064:1: rule__RefinedState__Group_5__1 : rule__RefinedState__Group_5__1__Impl ;
+    // InternalRoom.g:16293:1: rule__RefinedState__Group_5__1 : rule__RefinedState__Group_5__1__Impl ;
     public final void rule__RefinedState__Group_5__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16068:1: ( rule__RefinedState__Group_5__1__Impl )
-            // InternalRoom.g:16069:2: rule__RefinedState__Group_5__1__Impl
+            // InternalRoom.g:16297:1: ( rule__RefinedState__Group_5__1__Impl )
+            // InternalRoom.g:16298:2: rule__RefinedState__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_5__1__Impl();
@@ -44674,21 +45333,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_5__1__Impl"
-    // InternalRoom.g:16075:1: rule__RefinedState__Group_5__1__Impl : ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ;
+    // InternalRoom.g:16304:1: rule__RefinedState__Group_5__1__Impl : ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ;
     public final void rule__RefinedState__Group_5__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16079:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) )
-            // InternalRoom.g:16080:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
+            // InternalRoom.g:16308:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) )
+            // InternalRoom.g:16309:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
             {
-            // InternalRoom.g:16080:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
-            // InternalRoom.g:16081:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
+            // InternalRoom.g:16309:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
+            // InternalRoom.g:16310:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); 
-            // InternalRoom.g:16082:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
-            // InternalRoom.g:16082:2: rule__RefinedState__ExitCodeAssignment_5_1
+            // InternalRoom.g:16311:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
+            // InternalRoom.g:16311:2: rule__RefinedState__ExitCodeAssignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__ExitCodeAssignment_5_1();
@@ -44721,14 +45380,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__0"
-    // InternalRoom.g:16096:1: rule__RefinedState__Group_6__0 : rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ;
+    // InternalRoom.g:16325:1: rule__RefinedState__Group_6__0 : rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ;
     public final void rule__RefinedState__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16100:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 )
-            // InternalRoom.g:16101:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1
+            // InternalRoom.g:16329:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 )
+            // InternalRoom.g:16330:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_6__0__Impl();
@@ -44759,17 +45418,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__0__Impl"
-    // InternalRoom.g:16108:1: rule__RefinedState__Group_6__0__Impl : ( 'do' ) ;
+    // InternalRoom.g:16337:1: rule__RefinedState__Group_6__0__Impl : ( 'do' ) ;
     public final void rule__RefinedState__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16112:1: ( ( 'do' ) )
-            // InternalRoom.g:16113:1: ( 'do' )
+            // InternalRoom.g:16341:1: ( ( 'do' ) )
+            // InternalRoom.g:16342:1: ( 'do' )
             {
-            // InternalRoom.g:16113:1: ( 'do' )
-            // InternalRoom.g:16114:1: 'do'
+            // InternalRoom.g:16342:1: ( 'do' )
+            // InternalRoom.g:16343:1: 'do'
             {
              before(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); 
             match(input,98,FOLLOW_2); 
@@ -44796,14 +45455,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__1"
-    // InternalRoom.g:16127:1: rule__RefinedState__Group_6__1 : rule__RefinedState__Group_6__1__Impl ;
+    // InternalRoom.g:16356:1: rule__RefinedState__Group_6__1 : rule__RefinedState__Group_6__1__Impl ;
     public final void rule__RefinedState__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16131:1: ( rule__RefinedState__Group_6__1__Impl )
-            // InternalRoom.g:16132:2: rule__RefinedState__Group_6__1__Impl
+            // InternalRoom.g:16360:1: ( rule__RefinedState__Group_6__1__Impl )
+            // InternalRoom.g:16361:2: rule__RefinedState__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_6__1__Impl();
@@ -44829,21 +45488,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_6__1__Impl"
-    // InternalRoom.g:16138:1: rule__RefinedState__Group_6__1__Impl : ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ;
+    // InternalRoom.g:16367:1: rule__RefinedState__Group_6__1__Impl : ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ;
     public final void rule__RefinedState__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16142:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) )
-            // InternalRoom.g:16143:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
+            // InternalRoom.g:16371:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) )
+            // InternalRoom.g:16372:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
             {
-            // InternalRoom.g:16143:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
-            // InternalRoom.g:16144:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
+            // InternalRoom.g:16372:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
+            // InternalRoom.g:16373:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); 
-            // InternalRoom.g:16145:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
-            // InternalRoom.g:16145:2: rule__RefinedState__DoCodeAssignment_6_1
+            // InternalRoom.g:16374:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
+            // InternalRoom.g:16374:2: rule__RefinedState__DoCodeAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__DoCodeAssignment_6_1();
@@ -44876,14 +45535,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__0"
-    // InternalRoom.g:16159:1: rule__RefinedState__Group_7__0 : rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ;
+    // InternalRoom.g:16388:1: rule__RefinedState__Group_7__0 : rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ;
     public final void rule__RefinedState__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16163:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 )
-            // InternalRoom.g:16164:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1
+            // InternalRoom.g:16392:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 )
+            // InternalRoom.g:16393:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1
             {
             pushFollow(FOLLOW_40);
             rule__RefinedState__Group_7__0__Impl();
@@ -44914,17 +45573,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__0__Impl"
-    // InternalRoom.g:16171:1: rule__RefinedState__Group_7__0__Impl : ( 'subgraph' ) ;
+    // InternalRoom.g:16400:1: rule__RefinedState__Group_7__0__Impl : ( 'subgraph' ) ;
     public final void rule__RefinedState__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16175:1: ( ( 'subgraph' ) )
-            // InternalRoom.g:16176:1: ( 'subgraph' )
+            // InternalRoom.g:16404:1: ( ( 'subgraph' ) )
+            // InternalRoom.g:16405:1: ( 'subgraph' )
             {
-            // InternalRoom.g:16176:1: ( 'subgraph' )
-            // InternalRoom.g:16177:1: 'subgraph'
+            // InternalRoom.g:16405:1: ( 'subgraph' )
+            // InternalRoom.g:16406:1: 'subgraph'
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); 
             match(input,99,FOLLOW_2); 
@@ -44951,14 +45610,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__1"
-    // InternalRoom.g:16190:1: rule__RefinedState__Group_7__1 : rule__RefinedState__Group_7__1__Impl ;
+    // InternalRoom.g:16419:1: rule__RefinedState__Group_7__1 : rule__RefinedState__Group_7__1__Impl ;
     public final void rule__RefinedState__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16194:1: ( rule__RefinedState__Group_7__1__Impl )
-            // InternalRoom.g:16195:2: rule__RefinedState__Group_7__1__Impl
+            // InternalRoom.g:16423:1: ( rule__RefinedState__Group_7__1__Impl )
+            // InternalRoom.g:16424:2: rule__RefinedState__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_7__1__Impl();
@@ -44984,21 +45643,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group_7__1__Impl"
-    // InternalRoom.g:16201:1: rule__RefinedState__Group_7__1__Impl : ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ;
+    // InternalRoom.g:16430:1: rule__RefinedState__Group_7__1__Impl : ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ;
     public final void rule__RefinedState__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16205:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) )
-            // InternalRoom.g:16206:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
+            // InternalRoom.g:16434:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) )
+            // InternalRoom.g:16435:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
             {
-            // InternalRoom.g:16206:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
-            // InternalRoom.g:16207:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
+            // InternalRoom.g:16435:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
+            // InternalRoom.g:16436:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); 
-            // InternalRoom.g:16208:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
-            // InternalRoom.g:16208:2: rule__RefinedState__SubgraphAssignment_7_1
+            // InternalRoom.g:16437:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
+            // InternalRoom.g:16437:2: rule__RefinedState__SubgraphAssignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__SubgraphAssignment_7_1();
@@ -45031,16 +45690,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__0"
-    // InternalRoom.g:16222:1: rule__DetailCode__Group_0__0 : rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 ;
+    // InternalRoom.g:16451:1: rule__DetailCode__Group_0__0 : rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 ;
     public final void rule__DetailCode__Group_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16226:1: ( rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 )
-            // InternalRoom.g:16227:2: rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1
+            // InternalRoom.g:16455:1: ( rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 )
+            // InternalRoom.g:16456:2: rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1
             {
-            pushFollow(FOLLOW_82);
+            pushFollow(FOLLOW_83);
             rule__DetailCode__Group_0__0__Impl();
 
             state._fsp--;
@@ -45069,21 +45728,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__0__Impl"
-    // InternalRoom.g:16234:1: rule__DetailCode__Group_0__0__Impl : ( () ) ;
+    // InternalRoom.g:16463:1: rule__DetailCode__Group_0__0__Impl : ( () ) ;
     public final void rule__DetailCode__Group_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16238:1: ( ( () ) )
-            // InternalRoom.g:16239:1: ( () )
+            // InternalRoom.g:16467:1: ( ( () ) )
+            // InternalRoom.g:16468:1: ( () )
             {
-            // InternalRoom.g:16239:1: ( () )
-            // InternalRoom.g:16240:1: ()
+            // InternalRoom.g:16468:1: ( () )
+            // InternalRoom.g:16469:1: ()
             {
              before(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0_0()); 
-            // InternalRoom.g:16241:1: ()
-            // InternalRoom.g:16243:1: 
+            // InternalRoom.g:16470:1: ()
+            // InternalRoom.g:16472:1: 
             {
             }
 
@@ -45106,14 +45765,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__1"
-    // InternalRoom.g:16253:1: rule__DetailCode__Group_0__1 : rule__DetailCode__Group_0__1__Impl ;
+    // InternalRoom.g:16482:1: rule__DetailCode__Group_0__1 : rule__DetailCode__Group_0__1__Impl ;
     public final void rule__DetailCode__Group_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16257:1: ( rule__DetailCode__Group_0__1__Impl )
-            // InternalRoom.g:16258:2: rule__DetailCode__Group_0__1__Impl
+            // InternalRoom.g:16486:1: ( rule__DetailCode__Group_0__1__Impl )
+            // InternalRoom.g:16487:2: rule__DetailCode__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_0__1__Impl();
@@ -45139,29 +45798,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_0__1__Impl"
-    // InternalRoom.g:16264:1: rule__DetailCode__Group_0__1__Impl : ( ( rule__DetailCode__LinesAssignment_0_1 )? ) ;
+    // InternalRoom.g:16493:1: rule__DetailCode__Group_0__1__Impl : ( ( rule__DetailCode__LinesAssignment_0_1 )? ) ;
     public final void rule__DetailCode__Group_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16268:1: ( ( ( rule__DetailCode__LinesAssignment_0_1 )? ) )
-            // InternalRoom.g:16269:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
+            // InternalRoom.g:16497:1: ( ( ( rule__DetailCode__LinesAssignment_0_1 )? ) )
+            // InternalRoom.g:16498:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
             {
-            // InternalRoom.g:16269:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
-            // InternalRoom.g:16270:1: ( rule__DetailCode__LinesAssignment_0_1 )?
+            // InternalRoom.g:16498:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
+            // InternalRoom.g:16499:1: ( rule__DetailCode__LinesAssignment_0_1 )?
             {
              before(grammarAccess.getDetailCodeAccess().getLinesAssignment_0_1()); 
-            // InternalRoom.g:16271:1: ( rule__DetailCode__LinesAssignment_0_1 )?
-            int alt163=2;
-            int LA163_0 = input.LA(1);
+            // InternalRoom.g:16500:1: ( rule__DetailCode__LinesAssignment_0_1 )?
+            int alt166=2;
+            int LA166_0 = input.LA(1);
 
-            if ( (LA163_0==RULE_CC_STRING) ) {
-                alt163=1;
+            if ( (LA166_0==RULE_CC_STRING) ) {
+                alt166=1;
             }
-            switch (alt163) {
+            switch (alt166) {
                 case 1 :
-                    // InternalRoom.g:16271:2: rule__DetailCode__LinesAssignment_0_1
+                    // InternalRoom.g:16500:2: rule__DetailCode__LinesAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__LinesAssignment_0_1();
@@ -45197,16 +45856,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__0"
-    // InternalRoom.g:16285:1: rule__DetailCode__Group_1__0 : rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 ;
+    // InternalRoom.g:16514:1: rule__DetailCode__Group_1__0 : rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 ;
     public final void rule__DetailCode__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16289:1: ( rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 )
-            // InternalRoom.g:16290:2: rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1
+            // InternalRoom.g:16518:1: ( rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 )
+            // InternalRoom.g:16519:2: rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1
             {
-            pushFollow(FOLLOW_83);
+            pushFollow(FOLLOW_84);
             rule__DetailCode__Group_1__0__Impl();
 
             state._fsp--;
@@ -45235,21 +45894,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__0__Impl"
-    // InternalRoom.g:16297:1: rule__DetailCode__Group_1__0__Impl : ( ( rule__DetailCode__UsedAssignment_1_0 ) ) ;
+    // InternalRoom.g:16526:1: rule__DetailCode__Group_1__0__Impl : ( ( rule__DetailCode__UsedAssignment_1_0 ) ) ;
     public final void rule__DetailCode__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16301:1: ( ( ( rule__DetailCode__UsedAssignment_1_0 ) ) )
-            // InternalRoom.g:16302:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
+            // InternalRoom.g:16530:1: ( ( ( rule__DetailCode__UsedAssignment_1_0 ) ) )
+            // InternalRoom.g:16531:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
             {
-            // InternalRoom.g:16302:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
-            // InternalRoom.g:16303:1: ( rule__DetailCode__UsedAssignment_1_0 )
+            // InternalRoom.g:16531:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
+            // InternalRoom.g:16532:1: ( rule__DetailCode__UsedAssignment_1_0 )
             {
              before(grammarAccess.getDetailCodeAccess().getUsedAssignment_1_0()); 
-            // InternalRoom.g:16304:1: ( rule__DetailCode__UsedAssignment_1_0 )
-            // InternalRoom.g:16304:2: rule__DetailCode__UsedAssignment_1_0
+            // InternalRoom.g:16533:1: ( rule__DetailCode__UsedAssignment_1_0 )
+            // InternalRoom.g:16533:2: rule__DetailCode__UsedAssignment_1_0
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__UsedAssignment_1_0();
@@ -45282,16 +45941,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__1"
-    // InternalRoom.g:16314:1: rule__DetailCode__Group_1__1 : rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 ;
+    // InternalRoom.g:16543:1: rule__DetailCode__Group_1__1 : rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 ;
     public final void rule__DetailCode__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16318:1: ( rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 )
-            // InternalRoom.g:16319:2: rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2
+            // InternalRoom.g:16547:1: ( rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 )
+            // InternalRoom.g:16548:2: rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2
             {
-            pushFollow(FOLLOW_83);
+            pushFollow(FOLLOW_84);
             rule__DetailCode__Group_1__1__Impl();
 
             state._fsp--;
@@ -45320,35 +45979,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__1__Impl"
-    // InternalRoom.g:16326:1: rule__DetailCode__Group_1__1__Impl : ( ( rule__DetailCode__LinesAssignment_1_1 )* ) ;
+    // InternalRoom.g:16555:1: rule__DetailCode__Group_1__1__Impl : ( ( rule__DetailCode__LinesAssignment_1_1 )* ) ;
     public final void rule__DetailCode__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16330:1: ( ( ( rule__DetailCode__LinesAssignment_1_1 )* ) )
-            // InternalRoom.g:16331:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
+            // InternalRoom.g:16559:1: ( ( ( rule__DetailCode__LinesAssignment_1_1 )* ) )
+            // InternalRoom.g:16560:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
             {
-            // InternalRoom.g:16331:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
-            // InternalRoom.g:16332:1: ( rule__DetailCode__LinesAssignment_1_1 )*
+            // InternalRoom.g:16560:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
+            // InternalRoom.g:16561:1: ( rule__DetailCode__LinesAssignment_1_1 )*
             {
              before(grammarAccess.getDetailCodeAccess().getLinesAssignment_1_1()); 
-            // InternalRoom.g:16333:1: ( rule__DetailCode__LinesAssignment_1_1 )*
-            loop164:
+            // InternalRoom.g:16562:1: ( rule__DetailCode__LinesAssignment_1_1 )*
+            loop167:
             do {
-                int alt164=2;
-                int LA164_0 = input.LA(1);
+                int alt167=2;
+                int LA167_0 = input.LA(1);
 
-                if ( (LA164_0==RULE_STRING) ) {
-                    alt164=1;
+                if ( (LA167_0==RULE_STRING) ) {
+                    alt167=1;
                 }
 
 
-                switch (alt164) {
+                switch (alt167) {
             	case 1 :
-            	    // InternalRoom.g:16333:2: rule__DetailCode__LinesAssignment_1_1
+            	    // InternalRoom.g:16562:2: rule__DetailCode__LinesAssignment_1_1
             	    {
-            	    pushFollow(FOLLOW_84);
+            	    pushFollow(FOLLOW_85);
             	    rule__DetailCode__LinesAssignment_1_1();
 
             	    state._fsp--;
@@ -45358,7 +46017,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop164;
+            	    break loop167;
                 }
             } while (true);
 
@@ -45385,14 +46044,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__2"
-    // InternalRoom.g:16343:1: rule__DetailCode__Group_1__2 : rule__DetailCode__Group_1__2__Impl ;
+    // InternalRoom.g:16572:1: rule__DetailCode__Group_1__2 : rule__DetailCode__Group_1__2__Impl ;
     public final void rule__DetailCode__Group_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16347:1: ( rule__DetailCode__Group_1__2__Impl )
-            // InternalRoom.g:16348:2: rule__DetailCode__Group_1__2__Impl
+            // InternalRoom.g:16576:1: ( rule__DetailCode__Group_1__2__Impl )
+            // InternalRoom.g:16577:2: rule__DetailCode__Group_1__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_1__2__Impl();
@@ -45418,17 +46077,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__Group_1__2__Impl"
-    // InternalRoom.g:16354:1: rule__DetailCode__Group_1__2__Impl : ( '}' ) ;
+    // InternalRoom.g:16583:1: rule__DetailCode__Group_1__2__Impl : ( '}' ) ;
     public final void rule__DetailCode__Group_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16358:1: ( ( '}' ) )
-            // InternalRoom.g:16359:1: ( '}' )
+            // InternalRoom.g:16587:1: ( ( '}' ) )
+            // InternalRoom.g:16588:1: ( '}' )
             {
-            // InternalRoom.g:16359:1: ( '}' )
-            // InternalRoom.g:16360:1: '}'
+            // InternalRoom.g:16588:1: ( '}' )
+            // InternalRoom.g:16589:1: '}'
             {
              before(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_1_2()); 
             match(input,45,FOLLOW_2); 
@@ -45455,16 +46114,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__0"
-    // InternalRoom.g:16379:1: rule__TransitionPoint__Group__0 : rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ;
+    // InternalRoom.g:16608:1: rule__TransitionPoint__Group__0 : rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ;
     public final void rule__TransitionPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16383:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 )
-            // InternalRoom.g:16384:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1
+            // InternalRoom.g:16612:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 )
+            // InternalRoom.g:16613:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1
             {
-            pushFollow(FOLLOW_85);
+            pushFollow(FOLLOW_86);
             rule__TransitionPoint__Group__0__Impl();
 
             state._fsp--;
@@ -45493,29 +46152,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__0__Impl"
-    // InternalRoom.g:16391:1: rule__TransitionPoint__Group__0__Impl : ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ;
+    // InternalRoom.g:16620:1: rule__TransitionPoint__Group__0__Impl : ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ;
     public final void rule__TransitionPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16395:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) )
-            // InternalRoom.g:16396:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
+            // InternalRoom.g:16624:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) )
+            // InternalRoom.g:16625:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
             {
-            // InternalRoom.g:16396:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
-            // InternalRoom.g:16397:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            // InternalRoom.g:16625:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
+            // InternalRoom.g:16626:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); 
-            // InternalRoom.g:16398:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
-            int alt165=2;
-            int LA165_0 = input.LA(1);
+            // InternalRoom.g:16627:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            int alt168=2;
+            int LA168_0 = input.LA(1);
 
-            if ( (LA165_0==131) ) {
-                alt165=1;
+            if ( (LA168_0==131) ) {
+                alt168=1;
             }
-            switch (alt165) {
+            switch (alt168) {
                 case 1 :
-                    // InternalRoom.g:16398:2: rule__TransitionPoint__HandlerAssignment_0
+                    // InternalRoom.g:16627:2: rule__TransitionPoint__HandlerAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TransitionPoint__HandlerAssignment_0();
@@ -45551,14 +46210,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__1"
-    // InternalRoom.g:16408:1: rule__TransitionPoint__Group__1 : rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ;
+    // InternalRoom.g:16637:1: rule__TransitionPoint__Group__1 : rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ;
     public final void rule__TransitionPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16412:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 )
-            // InternalRoom.g:16413:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2
+            // InternalRoom.g:16641:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 )
+            // InternalRoom.g:16642:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__TransitionPoint__Group__1__Impl();
@@ -45589,17 +46248,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__1__Impl"
-    // InternalRoom.g:16420:1: rule__TransitionPoint__Group__1__Impl : ( 'TransitionPoint' ) ;
+    // InternalRoom.g:16649:1: rule__TransitionPoint__Group__1__Impl : ( 'TransitionPoint' ) ;
     public final void rule__TransitionPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16424:1: ( ( 'TransitionPoint' ) )
-            // InternalRoom.g:16425:1: ( 'TransitionPoint' )
+            // InternalRoom.g:16653:1: ( ( 'TransitionPoint' ) )
+            // InternalRoom.g:16654:1: ( 'TransitionPoint' )
             {
-            // InternalRoom.g:16425:1: ( 'TransitionPoint' )
-            // InternalRoom.g:16426:1: 'TransitionPoint'
+            // InternalRoom.g:16654:1: ( 'TransitionPoint' )
+            // InternalRoom.g:16655:1: 'TransitionPoint'
             {
              before(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); 
             match(input,101,FOLLOW_2); 
@@ -45626,14 +46285,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__2"
-    // InternalRoom.g:16439:1: rule__TransitionPoint__Group__2 : rule__TransitionPoint__Group__2__Impl ;
+    // InternalRoom.g:16668:1: rule__TransitionPoint__Group__2 : rule__TransitionPoint__Group__2__Impl ;
     public final void rule__TransitionPoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16443:1: ( rule__TransitionPoint__Group__2__Impl )
-            // InternalRoom.g:16444:2: rule__TransitionPoint__Group__2__Impl
+            // InternalRoom.g:16672:1: ( rule__TransitionPoint__Group__2__Impl )
+            // InternalRoom.g:16673:2: rule__TransitionPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__Group__2__Impl();
@@ -45659,21 +46318,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__Group__2__Impl"
-    // InternalRoom.g:16450:1: rule__TransitionPoint__Group__2__Impl : ( ( rule__TransitionPoint__NameAssignment_2 ) ) ;
+    // InternalRoom.g:16679:1: rule__TransitionPoint__Group__2__Impl : ( ( rule__TransitionPoint__NameAssignment_2 ) ) ;
     public final void rule__TransitionPoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16454:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) )
-            // InternalRoom.g:16455:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
+            // InternalRoom.g:16683:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) )
+            // InternalRoom.g:16684:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
             {
-            // InternalRoom.g:16455:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
-            // InternalRoom.g:16456:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalRoom.g:16684:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
+            // InternalRoom.g:16685:1: ( rule__TransitionPoint__NameAssignment_2 )
             {
              before(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); 
-            // InternalRoom.g:16457:1: ( rule__TransitionPoint__NameAssignment_2 )
-            // InternalRoom.g:16457:2: rule__TransitionPoint__NameAssignment_2
+            // InternalRoom.g:16686:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalRoom.g:16686:2: rule__TransitionPoint__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__NameAssignment_2();
@@ -45706,14 +46365,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__0"
-    // InternalRoom.g:16473:1: rule__EntryPoint__Group__0 : rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ;
+    // InternalRoom.g:16702:1: rule__EntryPoint__Group__0 : rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ;
     public final void rule__EntryPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16477:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 )
-            // InternalRoom.g:16478:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1
+            // InternalRoom.g:16706:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 )
+            // InternalRoom.g:16707:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__EntryPoint__Group__0__Impl();
@@ -45744,17 +46403,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__0__Impl"
-    // InternalRoom.g:16485:1: rule__EntryPoint__Group__0__Impl : ( 'EntryPoint' ) ;
+    // InternalRoom.g:16714:1: rule__EntryPoint__Group__0__Impl : ( 'EntryPoint' ) ;
     public final void rule__EntryPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16489:1: ( ( 'EntryPoint' ) )
-            // InternalRoom.g:16490:1: ( 'EntryPoint' )
+            // InternalRoom.g:16718:1: ( ( 'EntryPoint' ) )
+            // InternalRoom.g:16719:1: ( 'EntryPoint' )
             {
-            // InternalRoom.g:16490:1: ( 'EntryPoint' )
-            // InternalRoom.g:16491:1: 'EntryPoint'
+            // InternalRoom.g:16719:1: ( 'EntryPoint' )
+            // InternalRoom.g:16720:1: 'EntryPoint'
             {
              before(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); 
             match(input,102,FOLLOW_2); 
@@ -45781,14 +46440,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__1"
-    // InternalRoom.g:16504:1: rule__EntryPoint__Group__1 : rule__EntryPoint__Group__1__Impl ;
+    // InternalRoom.g:16733:1: rule__EntryPoint__Group__1 : rule__EntryPoint__Group__1__Impl ;
     public final void rule__EntryPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16508:1: ( rule__EntryPoint__Group__1__Impl )
-            // InternalRoom.g:16509:2: rule__EntryPoint__Group__1__Impl
+            // InternalRoom.g:16737:1: ( rule__EntryPoint__Group__1__Impl )
+            // InternalRoom.g:16738:2: rule__EntryPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__Group__1__Impl();
@@ -45814,21 +46473,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__Group__1__Impl"
-    // InternalRoom.g:16515:1: rule__EntryPoint__Group__1__Impl : ( ( rule__EntryPoint__NameAssignment_1 ) ) ;
+    // InternalRoom.g:16744:1: rule__EntryPoint__Group__1__Impl : ( ( rule__EntryPoint__NameAssignment_1 ) ) ;
     public final void rule__EntryPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16519:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) )
-            // InternalRoom.g:16520:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16748:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16749:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16520:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
-            // InternalRoom.g:16521:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalRoom.g:16749:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16750:1: ( rule__EntryPoint__NameAssignment_1 )
             {
              before(grammarAccess.getEntryPointAccess().getNameAssignment_1()); 
-            // InternalRoom.g:16522:1: ( rule__EntryPoint__NameAssignment_1 )
-            // InternalRoom.g:16522:2: rule__EntryPoint__NameAssignment_1
+            // InternalRoom.g:16751:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalRoom.g:16751:2: rule__EntryPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__NameAssignment_1();
@@ -45861,14 +46520,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__0"
-    // InternalRoom.g:16536:1: rule__ExitPoint__Group__0 : rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ;
+    // InternalRoom.g:16765:1: rule__ExitPoint__Group__0 : rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ;
     public final void rule__ExitPoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16540:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 )
-            // InternalRoom.g:16541:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1
+            // InternalRoom.g:16769:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 )
+            // InternalRoom.g:16770:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ExitPoint__Group__0__Impl();
@@ -45899,17 +46558,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__0__Impl"
-    // InternalRoom.g:16548:1: rule__ExitPoint__Group__0__Impl : ( 'ExitPoint' ) ;
+    // InternalRoom.g:16777:1: rule__ExitPoint__Group__0__Impl : ( 'ExitPoint' ) ;
     public final void rule__ExitPoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16552:1: ( ( 'ExitPoint' ) )
-            // InternalRoom.g:16553:1: ( 'ExitPoint' )
+            // InternalRoom.g:16781:1: ( ( 'ExitPoint' ) )
+            // InternalRoom.g:16782:1: ( 'ExitPoint' )
             {
-            // InternalRoom.g:16553:1: ( 'ExitPoint' )
-            // InternalRoom.g:16554:1: 'ExitPoint'
+            // InternalRoom.g:16782:1: ( 'ExitPoint' )
+            // InternalRoom.g:16783:1: 'ExitPoint'
             {
              before(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); 
             match(input,103,FOLLOW_2); 
@@ -45936,14 +46595,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__1"
-    // InternalRoom.g:16567:1: rule__ExitPoint__Group__1 : rule__ExitPoint__Group__1__Impl ;
+    // InternalRoom.g:16796:1: rule__ExitPoint__Group__1 : rule__ExitPoint__Group__1__Impl ;
     public final void rule__ExitPoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16571:1: ( rule__ExitPoint__Group__1__Impl )
-            // InternalRoom.g:16572:2: rule__ExitPoint__Group__1__Impl
+            // InternalRoom.g:16800:1: ( rule__ExitPoint__Group__1__Impl )
+            // InternalRoom.g:16801:2: rule__ExitPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__Group__1__Impl();
@@ -45969,21 +46628,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__Group__1__Impl"
-    // InternalRoom.g:16578:1: rule__ExitPoint__Group__1__Impl : ( ( rule__ExitPoint__NameAssignment_1 ) ) ;
+    // InternalRoom.g:16807:1: rule__ExitPoint__Group__1__Impl : ( ( rule__ExitPoint__NameAssignment_1 ) ) ;
     public final void rule__ExitPoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16582:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) )
-            // InternalRoom.g:16583:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16811:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16812:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16583:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
-            // InternalRoom.g:16584:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalRoom.g:16812:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16813:1: ( rule__ExitPoint__NameAssignment_1 )
             {
              before(grammarAccess.getExitPointAccess().getNameAssignment_1()); 
-            // InternalRoom.g:16585:1: ( rule__ExitPoint__NameAssignment_1 )
-            // InternalRoom.g:16585:2: rule__ExitPoint__NameAssignment_1
+            // InternalRoom.g:16814:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalRoom.g:16814:2: rule__ExitPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__NameAssignment_1();
@@ -46016,14 +46675,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__0"
-    // InternalRoom.g:16599:1: rule__ChoicePoint__Group__0 : rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ;
+    // InternalRoom.g:16828:1: rule__ChoicePoint__Group__0 : rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ;
     public final void rule__ChoicePoint__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16603:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 )
-            // InternalRoom.g:16604:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1
+            // InternalRoom.g:16832:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 )
+            // InternalRoom.g:16833:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ChoicePoint__Group__0__Impl();
@@ -46054,17 +46713,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__0__Impl"
-    // InternalRoom.g:16611:1: rule__ChoicePoint__Group__0__Impl : ( 'ChoicePoint' ) ;
+    // InternalRoom.g:16840:1: rule__ChoicePoint__Group__0__Impl : ( 'ChoicePoint' ) ;
     public final void rule__ChoicePoint__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16615:1: ( ( 'ChoicePoint' ) )
-            // InternalRoom.g:16616:1: ( 'ChoicePoint' )
+            // InternalRoom.g:16844:1: ( ( 'ChoicePoint' ) )
+            // InternalRoom.g:16845:1: ( 'ChoicePoint' )
             {
-            // InternalRoom.g:16616:1: ( 'ChoicePoint' )
-            // InternalRoom.g:16617:1: 'ChoicePoint'
+            // InternalRoom.g:16845:1: ( 'ChoicePoint' )
+            // InternalRoom.g:16846:1: 'ChoicePoint'
             {
              before(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); 
             match(input,104,FOLLOW_2); 
@@ -46091,14 +46750,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__1"
-    // InternalRoom.g:16630:1: rule__ChoicePoint__Group__1 : rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ;
+    // InternalRoom.g:16859:1: rule__ChoicePoint__Group__1 : rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ;
     public final void rule__ChoicePoint__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16634:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 )
-            // InternalRoom.g:16635:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2
+            // InternalRoom.g:16863:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 )
+            // InternalRoom.g:16864:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2
             {
             pushFollow(FOLLOW_14);
             rule__ChoicePoint__Group__1__Impl();
@@ -46129,21 +46788,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__1__Impl"
-    // InternalRoom.g:16642:1: rule__ChoicePoint__Group__1__Impl : ( ( rule__ChoicePoint__NameAssignment_1 ) ) ;
+    // InternalRoom.g:16871:1: rule__ChoicePoint__Group__1__Impl : ( ( rule__ChoicePoint__NameAssignment_1 ) ) ;
     public final void rule__ChoicePoint__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16646:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) )
-            // InternalRoom.g:16647:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
+            // InternalRoom.g:16875:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16876:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16647:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
-            // InternalRoom.g:16648:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalRoom.g:16876:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
+            // InternalRoom.g:16877:1: ( rule__ChoicePoint__NameAssignment_1 )
             {
              before(grammarAccess.getChoicePointAccess().getNameAssignment_1()); 
-            // InternalRoom.g:16649:1: ( rule__ChoicePoint__NameAssignment_1 )
-            // InternalRoom.g:16649:2: rule__ChoicePoint__NameAssignment_1
+            // InternalRoom.g:16878:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalRoom.g:16878:2: rule__ChoicePoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__NameAssignment_1();
@@ -46176,14 +46835,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__2"
-    // InternalRoom.g:16659:1: rule__ChoicePoint__Group__2 : rule__ChoicePoint__Group__2__Impl ;
+    // InternalRoom.g:16888:1: rule__ChoicePoint__Group__2 : rule__ChoicePoint__Group__2__Impl ;
     public final void rule__ChoicePoint__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16663:1: ( rule__ChoicePoint__Group__2__Impl )
-            // InternalRoom.g:16664:2: rule__ChoicePoint__Group__2__Impl
+            // InternalRoom.g:16892:1: ( rule__ChoicePoint__Group__2__Impl )
+            // InternalRoom.g:16893:2: rule__ChoicePoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__Group__2__Impl();
@@ -46209,29 +46868,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__Group__2__Impl"
-    // InternalRoom.g:16670:1: rule__ChoicePoint__Group__2__Impl : ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:16899:1: rule__ChoicePoint__Group__2__Impl : ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ;
     public final void rule__ChoicePoint__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16674:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) )
-            // InternalRoom.g:16675:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
+            // InternalRoom.g:16903:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) )
+            // InternalRoom.g:16904:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:16675:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
-            // InternalRoom.g:16676:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            // InternalRoom.g:16904:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
+            // InternalRoom.g:16905:1: ( rule__ChoicePoint__DocuAssignment_2 )?
             {
              before(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:16677:1: ( rule__ChoicePoint__DocuAssignment_2 )?
-            int alt166=2;
-            int LA166_0 = input.LA(1);
+            // InternalRoom.g:16906:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            int alt169=2;
+            int LA169_0 = input.LA(1);
 
-            if ( (LA166_0==62) ) {
-                alt166=1;
+            if ( (LA169_0==62) ) {
+                alt169=1;
             }
-            switch (alt166) {
+            switch (alt169) {
                 case 1 :
-                    // InternalRoom.g:16677:2: rule__ChoicePoint__DocuAssignment_2
+                    // InternalRoom.g:16906:2: rule__ChoicePoint__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__ChoicePoint__DocuAssignment_2();
@@ -46267,16 +46926,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__0"
-    // InternalRoom.g:16693:1: rule__InitialTransition__Group__0 : rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ;
+    // InternalRoom.g:16922:1: rule__InitialTransition__Group__0 : rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ;
     public final void rule__InitialTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16697:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 )
-            // InternalRoom.g:16698:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1
+            // InternalRoom.g:16926:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 )
+            // InternalRoom.g:16927:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__InitialTransition__Group__0__Impl();
 
             state._fsp--;
@@ -46305,17 +46964,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__0__Impl"
-    // InternalRoom.g:16705:1: rule__InitialTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalRoom.g:16934:1: rule__InitialTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__InitialTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16709:1: ( ( 'Transition' ) )
-            // InternalRoom.g:16710:1: ( 'Transition' )
+            // InternalRoom.g:16938:1: ( ( 'Transition' ) )
+            // InternalRoom.g:16939:1: ( 'Transition' )
             {
-            // InternalRoom.g:16710:1: ( 'Transition' )
-            // InternalRoom.g:16711:1: 'Transition'
+            // InternalRoom.g:16939:1: ( 'Transition' )
+            // InternalRoom.g:16940:1: 'Transition'
             {
              before(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -46342,16 +47001,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__1"
-    // InternalRoom.g:16724:1: rule__InitialTransition__Group__1 : rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ;
+    // InternalRoom.g:16953:1: rule__InitialTransition__Group__1 : rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ;
     public final void rule__InitialTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16728:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 )
-            // InternalRoom.g:16729:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2
+            // InternalRoom.g:16957:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 )
+            // InternalRoom.g:16958:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__InitialTransition__Group__1__Impl();
 
             state._fsp--;
@@ -46380,29 +47039,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__1__Impl"
-    // InternalRoom.g:16736:1: rule__InitialTransition__Group__1__Impl : ( ( rule__InitialTransition__NameAssignment_1 )? ) ;
+    // InternalRoom.g:16965:1: rule__InitialTransition__Group__1__Impl : ( ( rule__InitialTransition__NameAssignment_1 )? ) ;
     public final void rule__InitialTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16740:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) )
-            // InternalRoom.g:16741:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
+            // InternalRoom.g:16969:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:16970:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:16741:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
-            // InternalRoom.g:16742:1: ( rule__InitialTransition__NameAssignment_1 )?
+            // InternalRoom.g:16970:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
+            // InternalRoom.g:16971:1: ( rule__InitialTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); 
-            // InternalRoom.g:16743:1: ( rule__InitialTransition__NameAssignment_1 )?
-            int alt167=2;
-            int LA167_0 = input.LA(1);
+            // InternalRoom.g:16972:1: ( rule__InitialTransition__NameAssignment_1 )?
+            int alt170=2;
+            int LA170_0 = input.LA(1);
 
-            if ( (LA167_0==RULE_ID) ) {
-                alt167=1;
+            if ( (LA170_0==RULE_ID) ) {
+                alt170=1;
             }
-            switch (alt167) {
+            switch (alt170) {
                 case 1 :
-                    // InternalRoom.g:16743:2: rule__InitialTransition__NameAssignment_1
+                    // InternalRoom.g:16972:2: rule__InitialTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__NameAssignment_1();
@@ -46438,16 +47097,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__2"
-    // InternalRoom.g:16753:1: rule__InitialTransition__Group__2 : rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ;
+    // InternalRoom.g:16982:1: rule__InitialTransition__Group__2 : rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ;
     public final void rule__InitialTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16757:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 )
-            // InternalRoom.g:16758:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3
+            // InternalRoom.g:16986:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 )
+            // InternalRoom.g:16987:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3
             {
-            pushFollow(FOLLOW_87);
+            pushFollow(FOLLOW_88);
             rule__InitialTransition__Group__2__Impl();
 
             state._fsp--;
@@ -46476,17 +47135,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__2__Impl"
-    // InternalRoom.g:16765:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:16994:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__InitialTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16769:1: ( ( ':' ) )
-            // InternalRoom.g:16770:1: ( ':' )
+            // InternalRoom.g:16998:1: ( ( ':' ) )
+            // InternalRoom.g:16999:1: ( ':' )
             {
-            // InternalRoom.g:16770:1: ( ':' )
-            // InternalRoom.g:16771:1: ':'
+            // InternalRoom.g:16999:1: ( ':' )
+            // InternalRoom.g:17000:1: ':'
             {
              before(grammarAccess.getInitialTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -46513,14 +47172,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__3"
-    // InternalRoom.g:16784:1: rule__InitialTransition__Group__3 : rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ;
+    // InternalRoom.g:17013:1: rule__InitialTransition__Group__3 : rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ;
     public final void rule__InitialTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16788:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 )
-            // InternalRoom.g:16789:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4
+            // InternalRoom.g:17017:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 )
+            // InternalRoom.g:17018:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__InitialTransition__Group__3__Impl();
@@ -46551,17 +47210,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__3__Impl"
-    // InternalRoom.g:16796:1: rule__InitialTransition__Group__3__Impl : ( 'initial' ) ;
+    // InternalRoom.g:17025:1: rule__InitialTransition__Group__3__Impl : ( 'initial' ) ;
     public final void rule__InitialTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16800:1: ( ( 'initial' ) )
-            // InternalRoom.g:16801:1: ( 'initial' )
+            // InternalRoom.g:17029:1: ( ( 'initial' ) )
+            // InternalRoom.g:17030:1: ( 'initial' )
             {
-            // InternalRoom.g:16801:1: ( 'initial' )
-            // InternalRoom.g:16802:1: 'initial'
+            // InternalRoom.g:17030:1: ( 'initial' )
+            // InternalRoom.g:17031:1: 'initial'
             {
              before(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); 
             match(input,106,FOLLOW_2); 
@@ -46588,16 +47247,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__4"
-    // InternalRoom.g:16815:1: rule__InitialTransition__Group__4 : rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ;
+    // InternalRoom.g:17044:1: rule__InitialTransition__Group__4 : rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ;
     public final void rule__InitialTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16819:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 )
-            // InternalRoom.g:16820:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5
+            // InternalRoom.g:17048:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 )
+            // InternalRoom.g:17049:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__InitialTransition__Group__4__Impl();
 
             state._fsp--;
@@ -46626,17 +47285,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__4__Impl"
-    // InternalRoom.g:16827:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:17056:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__InitialTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16831:1: ( ( '->' ) )
-            // InternalRoom.g:16832:1: ( '->' )
+            // InternalRoom.g:17060:1: ( ( '->' ) )
+            // InternalRoom.g:17061:1: ( '->' )
             {
-            // InternalRoom.g:16832:1: ( '->' )
-            // InternalRoom.g:16833:1: '->'
+            // InternalRoom.g:17061:1: ( '->' )
+            // InternalRoom.g:17062:1: '->'
             {
              before(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -46663,14 +47322,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__5"
-    // InternalRoom.g:16846:1: rule__InitialTransition__Group__5 : rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ;
+    // InternalRoom.g:17075:1: rule__InitialTransition__Group__5 : rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ;
     public final void rule__InitialTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16850:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 )
-            // InternalRoom.g:16851:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6
+            // InternalRoom.g:17079:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 )
+            // InternalRoom.g:17080:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__InitialTransition__Group__5__Impl();
@@ -46701,21 +47360,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__5__Impl"
-    // InternalRoom.g:16858:1: rule__InitialTransition__Group__5__Impl : ( ( rule__InitialTransition__ToAssignment_5 ) ) ;
+    // InternalRoom.g:17087:1: rule__InitialTransition__Group__5__Impl : ( ( rule__InitialTransition__ToAssignment_5 ) ) ;
     public final void rule__InitialTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16862:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) )
-            // InternalRoom.g:16863:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17091:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:17092:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:16863:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
-            // InternalRoom.g:16864:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalRoom.g:17092:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17093:1: ( rule__InitialTransition__ToAssignment_5 )
             {
              before(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); 
-            // InternalRoom.g:16865:1: ( rule__InitialTransition__ToAssignment_5 )
-            // InternalRoom.g:16865:2: rule__InitialTransition__ToAssignment_5
+            // InternalRoom.g:17094:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalRoom.g:17094:2: rule__InitialTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ToAssignment_5();
@@ -46748,14 +47407,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__6"
-    // InternalRoom.g:16875:1: rule__InitialTransition__Group__6 : rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ;
+    // InternalRoom.g:17104:1: rule__InitialTransition__Group__6 : rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ;
     public final void rule__InitialTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16879:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 )
-            // InternalRoom.g:16880:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7
+            // InternalRoom.g:17108:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 )
+            // InternalRoom.g:17109:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__InitialTransition__Group__6__Impl();
@@ -46786,29 +47445,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__6__Impl"
-    // InternalRoom.g:16887:1: rule__InitialTransition__Group__6__Impl : ( ( rule__InitialTransition__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:17116:1: rule__InitialTransition__Group__6__Impl : ( ( rule__InitialTransition__DocuAssignment_6 )? ) ;
     public final void rule__InitialTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16891:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) )
-            // InternalRoom.g:16892:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17120:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:17121:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:16892:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:16893:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            // InternalRoom.g:17121:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17122:1: ( rule__InitialTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:16894:1: ( rule__InitialTransition__DocuAssignment_6 )?
-            int alt168=2;
-            int LA168_0 = input.LA(1);
+            // InternalRoom.g:17123:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            int alt171=2;
+            int LA171_0 = input.LA(1);
 
-            if ( (LA168_0==62) ) {
-                alt168=1;
+            if ( (LA171_0==62) ) {
+                alt171=1;
             }
-            switch (alt168) {
+            switch (alt171) {
                 case 1 :
-                    // InternalRoom.g:16894:2: rule__InitialTransition__DocuAssignment_6
+                    // InternalRoom.g:17123:2: rule__InitialTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__DocuAssignment_6();
@@ -46844,14 +47503,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__7"
-    // InternalRoom.g:16904:1: rule__InitialTransition__Group__7 : rule__InitialTransition__Group__7__Impl ;
+    // InternalRoom.g:17133:1: rule__InitialTransition__Group__7 : rule__InitialTransition__Group__7__Impl ;
     public final void rule__InitialTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16908:1: ( rule__InitialTransition__Group__7__Impl )
-            // InternalRoom.g:16909:2: rule__InitialTransition__Group__7__Impl
+            // InternalRoom.g:17137:1: ( rule__InitialTransition__Group__7__Impl )
+            // InternalRoom.g:17138:2: rule__InitialTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__7__Impl();
@@ -46877,29 +47536,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__7__Impl"
-    // InternalRoom.g:16915:1: rule__InitialTransition__Group__7__Impl : ( ( rule__InitialTransition__Group_7__0 )? ) ;
+    // InternalRoom.g:17144:1: rule__InitialTransition__Group__7__Impl : ( ( rule__InitialTransition__Group_7__0 )? ) ;
     public final void rule__InitialTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16919:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) )
-            // InternalRoom.g:16920:1: ( ( rule__InitialTransition__Group_7__0 )? )
+            // InternalRoom.g:17148:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) )
+            // InternalRoom.g:17149:1: ( ( rule__InitialTransition__Group_7__0 )? )
             {
-            // InternalRoom.g:16920:1: ( ( rule__InitialTransition__Group_7__0 )? )
-            // InternalRoom.g:16921:1: ( rule__InitialTransition__Group_7__0 )?
+            // InternalRoom.g:17149:1: ( ( rule__InitialTransition__Group_7__0 )? )
+            // InternalRoom.g:17150:1: ( rule__InitialTransition__Group_7__0 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup_7()); 
-            // InternalRoom.g:16922:1: ( rule__InitialTransition__Group_7__0 )?
-            int alt169=2;
-            int LA169_0 = input.LA(1);
+            // InternalRoom.g:17151:1: ( rule__InitialTransition__Group_7__0 )?
+            int alt172=2;
+            int LA172_0 = input.LA(1);
 
-            if ( (LA169_0==44) ) {
-                alt169=1;
+            if ( (LA172_0==44) ) {
+                alt172=1;
             }
-            switch (alt169) {
+            switch (alt172) {
                 case 1 :
-                    // InternalRoom.g:16922:2: rule__InitialTransition__Group_7__0
+                    // InternalRoom.g:17151:2: rule__InitialTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7__0();
@@ -46935,16 +47594,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__0"
-    // InternalRoom.g:16948:1: rule__InitialTransition__Group_7__0 : rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ;
+    // InternalRoom.g:17177:1: rule__InitialTransition__Group_7__0 : rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ;
     public final void rule__InitialTransition__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16952:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 )
-            // InternalRoom.g:16953:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1
+            // InternalRoom.g:17181:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 )
+            // InternalRoom.g:17182:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__InitialTransition__Group_7__0__Impl();
 
             state._fsp--;
@@ -46973,17 +47632,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__0__Impl"
-    // InternalRoom.g:16960:1: rule__InitialTransition__Group_7__0__Impl : ( '{' ) ;
+    // InternalRoom.g:17189:1: rule__InitialTransition__Group_7__0__Impl : ( '{' ) ;
     public final void rule__InitialTransition__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16964:1: ( ( '{' ) )
-            // InternalRoom.g:16965:1: ( '{' )
+            // InternalRoom.g:17193:1: ( ( '{' ) )
+            // InternalRoom.g:17194:1: ( '{' )
             {
-            // InternalRoom.g:16965:1: ( '{' )
-            // InternalRoom.g:16966:1: '{'
+            // InternalRoom.g:17194:1: ( '{' )
+            // InternalRoom.g:17195:1: '{'
             {
              before(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,44,FOLLOW_2); 
@@ -47010,16 +47669,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__1"
-    // InternalRoom.g:16979:1: rule__InitialTransition__Group_7__1 : rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ;
+    // InternalRoom.g:17208:1: rule__InitialTransition__Group_7__1 : rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ;
     public final void rule__InitialTransition__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16983:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 )
-            // InternalRoom.g:16984:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2
+            // InternalRoom.g:17212:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 )
+            // InternalRoom.g:17213:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__InitialTransition__Group_7__1__Impl();
 
             state._fsp--;
@@ -47048,29 +47707,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__1__Impl"
-    // InternalRoom.g:16991:1: rule__InitialTransition__Group_7__1__Impl : ( ( rule__InitialTransition__Group_7_1__0 )? ) ;
+    // InternalRoom.g:17220:1: rule__InitialTransition__Group_7__1__Impl : ( ( rule__InitialTransition__Group_7_1__0 )? ) ;
     public final void rule__InitialTransition__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:16995:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) )
-            // InternalRoom.g:16996:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17224:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) )
+            // InternalRoom.g:17225:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
             {
-            // InternalRoom.g:16996:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
-            // InternalRoom.g:16997:1: ( rule__InitialTransition__Group_7_1__0 )?
+            // InternalRoom.g:17225:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17226:1: ( rule__InitialTransition__Group_7_1__0 )?
             {
              before(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); 
-            // InternalRoom.g:16998:1: ( rule__InitialTransition__Group_7_1__0 )?
-            int alt170=2;
-            int LA170_0 = input.LA(1);
+            // InternalRoom.g:17227:1: ( rule__InitialTransition__Group_7_1__0 )?
+            int alt173=2;
+            int LA173_0 = input.LA(1);
 
-            if ( (LA170_0==107) ) {
-                alt170=1;
+            if ( (LA173_0==107) ) {
+                alt173=1;
             }
-            switch (alt170) {
+            switch (alt173) {
                 case 1 :
-                    // InternalRoom.g:16998:2: rule__InitialTransition__Group_7_1__0
+                    // InternalRoom.g:17227:2: rule__InitialTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7_1__0();
@@ -47106,14 +47765,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__2"
-    // InternalRoom.g:17008:1: rule__InitialTransition__Group_7__2 : rule__InitialTransition__Group_7__2__Impl ;
+    // InternalRoom.g:17237:1: rule__InitialTransition__Group_7__2 : rule__InitialTransition__Group_7__2__Impl ;
     public final void rule__InitialTransition__Group_7__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17012:1: ( rule__InitialTransition__Group_7__2__Impl )
-            // InternalRoom.g:17013:2: rule__InitialTransition__Group_7__2__Impl
+            // InternalRoom.g:17241:1: ( rule__InitialTransition__Group_7__2__Impl )
+            // InternalRoom.g:17242:2: rule__InitialTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7__2__Impl();
@@ -47139,17 +47798,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7__2__Impl"
-    // InternalRoom.g:17019:1: rule__InitialTransition__Group_7__2__Impl : ( '}' ) ;
+    // InternalRoom.g:17248:1: rule__InitialTransition__Group_7__2__Impl : ( '}' ) ;
     public final void rule__InitialTransition__Group_7__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17023:1: ( ( '}' ) )
-            // InternalRoom.g:17024:1: ( '}' )
+            // InternalRoom.g:17252:1: ( ( '}' ) )
+            // InternalRoom.g:17253:1: ( '}' )
             {
-            // InternalRoom.g:17024:1: ( '}' )
-            // InternalRoom.g:17025:1: '}'
+            // InternalRoom.g:17253:1: ( '}' )
+            // InternalRoom.g:17254:1: '}'
             {
              before(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,45,FOLLOW_2); 
@@ -47176,14 +47835,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__0"
-    // InternalRoom.g:17044:1: rule__InitialTransition__Group_7_1__0 : rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ;
+    // InternalRoom.g:17273:1: rule__InitialTransition__Group_7_1__0 : rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ;
     public final void rule__InitialTransition__Group_7_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17048:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 )
-            // InternalRoom.g:17049:2: rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1
+            // InternalRoom.g:17277:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 )
+            // InternalRoom.g:17278:2: rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1
             {
             pushFollow(FOLLOW_27);
             rule__InitialTransition__Group_7_1__0__Impl();
@@ -47214,17 +47873,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__0__Impl"
-    // InternalRoom.g:17056:1: rule__InitialTransition__Group_7_1__0__Impl : ( 'action' ) ;
+    // InternalRoom.g:17285:1: rule__InitialTransition__Group_7_1__0__Impl : ( 'action' ) ;
     public final void rule__InitialTransition__Group_7_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17060:1: ( ( 'action' ) )
-            // InternalRoom.g:17061:1: ( 'action' )
+            // InternalRoom.g:17289:1: ( ( 'action' ) )
+            // InternalRoom.g:17290:1: ( 'action' )
             {
-            // InternalRoom.g:17061:1: ( 'action' )
-            // InternalRoom.g:17062:1: 'action'
+            // InternalRoom.g:17290:1: ( 'action' )
+            // InternalRoom.g:17291:1: 'action'
             {
              before(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,107,FOLLOW_2); 
@@ -47251,14 +47910,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__1"
-    // InternalRoom.g:17075:1: rule__InitialTransition__Group_7_1__1 : rule__InitialTransition__Group_7_1__1__Impl ;
+    // InternalRoom.g:17304:1: rule__InitialTransition__Group_7_1__1 : rule__InitialTransition__Group_7_1__1__Impl ;
     public final void rule__InitialTransition__Group_7_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17079:1: ( rule__InitialTransition__Group_7_1__1__Impl )
-            // InternalRoom.g:17080:2: rule__InitialTransition__Group_7_1__1__Impl
+            // InternalRoom.g:17308:1: ( rule__InitialTransition__Group_7_1__1__Impl )
+            // InternalRoom.g:17309:2: rule__InitialTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7_1__1__Impl();
@@ -47284,21 +47943,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group_7_1__1__Impl"
-    // InternalRoom.g:17086:1: rule__InitialTransition__Group_7_1__1__Impl : ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ;
+    // InternalRoom.g:17315:1: rule__InitialTransition__Group_7_1__1__Impl : ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ;
     public final void rule__InitialTransition__Group_7_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17090:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) )
-            // InternalRoom.g:17091:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17319:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalRoom.g:17320:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
             {
-            // InternalRoom.g:17091:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
-            // InternalRoom.g:17092:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17320:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17321:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
             {
              before(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); 
-            // InternalRoom.g:17093:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
-            // InternalRoom.g:17093:2: rule__InitialTransition__ActionAssignment_7_1_1
+            // InternalRoom.g:17322:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17322:2: rule__InitialTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ActionAssignment_7_1_1();
@@ -47331,16 +47990,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__0"
-    // InternalRoom.g:17107:1: rule__ContinuationTransition__Group__0 : rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ;
+    // InternalRoom.g:17336:1: rule__ContinuationTransition__Group__0 : rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ;
     public final void rule__ContinuationTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17111:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 )
-            // InternalRoom.g:17112:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1
+            // InternalRoom.g:17340:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 )
+            // InternalRoom.g:17341:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__ContinuationTransition__Group__0__Impl();
 
             state._fsp--;
@@ -47369,17 +48028,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__0__Impl"
-    // InternalRoom.g:17119:1: rule__ContinuationTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalRoom.g:17348:1: rule__ContinuationTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__ContinuationTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17123:1: ( ( 'Transition' ) )
-            // InternalRoom.g:17124:1: ( 'Transition' )
+            // InternalRoom.g:17352:1: ( ( 'Transition' ) )
+            // InternalRoom.g:17353:1: ( 'Transition' )
             {
-            // InternalRoom.g:17124:1: ( 'Transition' )
-            // InternalRoom.g:17125:1: 'Transition'
+            // InternalRoom.g:17353:1: ( 'Transition' )
+            // InternalRoom.g:17354:1: 'Transition'
             {
              before(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -47406,16 +48065,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__1"
-    // InternalRoom.g:17138:1: rule__ContinuationTransition__Group__1 : rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ;
+    // InternalRoom.g:17367:1: rule__ContinuationTransition__Group__1 : rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ;
     public final void rule__ContinuationTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17142:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 )
-            // InternalRoom.g:17143:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2
+            // InternalRoom.g:17371:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 )
+            // InternalRoom.g:17372:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__ContinuationTransition__Group__1__Impl();
 
             state._fsp--;
@@ -47444,29 +48103,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__1__Impl"
-    // InternalRoom.g:17150:1: rule__ContinuationTransition__Group__1__Impl : ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ;
+    // InternalRoom.g:17379:1: rule__ContinuationTransition__Group__1__Impl : ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ;
     public final void rule__ContinuationTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17154:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) )
-            // InternalRoom.g:17155:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17383:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:17384:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:17155:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
-            // InternalRoom.g:17156:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            // InternalRoom.g:17384:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17385:1: ( rule__ContinuationTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); 
-            // InternalRoom.g:17157:1: ( rule__ContinuationTransition__NameAssignment_1 )?
-            int alt171=2;
-            int LA171_0 = input.LA(1);
+            // InternalRoom.g:17386:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            int alt174=2;
+            int LA174_0 = input.LA(1);
 
-            if ( (LA171_0==RULE_ID) ) {
-                alt171=1;
+            if ( (LA174_0==RULE_ID) ) {
+                alt174=1;
             }
-            switch (alt171) {
+            switch (alt174) {
                 case 1 :
-                    // InternalRoom.g:17157:2: rule__ContinuationTransition__NameAssignment_1
+                    // InternalRoom.g:17386:2: rule__ContinuationTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__NameAssignment_1();
@@ -47502,16 +48161,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__2"
-    // InternalRoom.g:17167:1: rule__ContinuationTransition__Group__2 : rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ;
+    // InternalRoom.g:17396:1: rule__ContinuationTransition__Group__2 : rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ;
     public final void rule__ContinuationTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17171:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 )
-            // InternalRoom.g:17172:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3
+            // InternalRoom.g:17400:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 )
+            // InternalRoom.g:17401:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__ContinuationTransition__Group__2__Impl();
 
             state._fsp--;
@@ -47540,17 +48199,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__2__Impl"
-    // InternalRoom.g:17179:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:17408:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__ContinuationTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17183:1: ( ( ':' ) )
-            // InternalRoom.g:17184:1: ( ':' )
+            // InternalRoom.g:17412:1: ( ( ':' ) )
+            // InternalRoom.g:17413:1: ( ':' )
             {
-            // InternalRoom.g:17184:1: ( ':' )
-            // InternalRoom.g:17185:1: ':'
+            // InternalRoom.g:17413:1: ( ':' )
+            // InternalRoom.g:17414:1: ':'
             {
              before(grammarAccess.getContinuationTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -47577,14 +48236,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__3"
-    // InternalRoom.g:17198:1: rule__ContinuationTransition__Group__3 : rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ;
+    // InternalRoom.g:17427:1: rule__ContinuationTransition__Group__3 : rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ;
     public final void rule__ContinuationTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17202:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 )
-            // InternalRoom.g:17203:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4
+            // InternalRoom.g:17431:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 )
+            // InternalRoom.g:17432:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__ContinuationTransition__Group__3__Impl();
@@ -47615,21 +48274,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__3__Impl"
-    // InternalRoom.g:17210:1: rule__ContinuationTransition__Group__3__Impl : ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ;
+    // InternalRoom.g:17439:1: rule__ContinuationTransition__Group__3__Impl : ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ;
     public final void rule__ContinuationTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17214:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) )
-            // InternalRoom.g:17215:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17443:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:17444:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:17215:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
-            // InternalRoom.g:17216:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalRoom.g:17444:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17445:1: ( rule__ContinuationTransition__FromAssignment_3 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); 
-            // InternalRoom.g:17217:1: ( rule__ContinuationTransition__FromAssignment_3 )
-            // InternalRoom.g:17217:2: rule__ContinuationTransition__FromAssignment_3
+            // InternalRoom.g:17446:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalRoom.g:17446:2: rule__ContinuationTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__FromAssignment_3();
@@ -47662,16 +48321,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__4"
-    // InternalRoom.g:17227:1: rule__ContinuationTransition__Group__4 : rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ;
+    // InternalRoom.g:17456:1: rule__ContinuationTransition__Group__4 : rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ;
     public final void rule__ContinuationTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17231:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 )
-            // InternalRoom.g:17232:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5
+            // InternalRoom.g:17460:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 )
+            // InternalRoom.g:17461:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__ContinuationTransition__Group__4__Impl();
 
             state._fsp--;
@@ -47700,17 +48359,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__4__Impl"
-    // InternalRoom.g:17239:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:17468:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__ContinuationTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17243:1: ( ( '->' ) )
-            // InternalRoom.g:17244:1: ( '->' )
+            // InternalRoom.g:17472:1: ( ( '->' ) )
+            // InternalRoom.g:17473:1: ( '->' )
             {
-            // InternalRoom.g:17244:1: ( '->' )
-            // InternalRoom.g:17245:1: '->'
+            // InternalRoom.g:17473:1: ( '->' )
+            // InternalRoom.g:17474:1: '->'
             {
              before(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -47737,14 +48396,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__5"
-    // InternalRoom.g:17258:1: rule__ContinuationTransition__Group__5 : rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ;
+    // InternalRoom.g:17487:1: rule__ContinuationTransition__Group__5 : rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ;
     public final void rule__ContinuationTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17262:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 )
-            // InternalRoom.g:17263:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6
+            // InternalRoom.g:17491:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 )
+            // InternalRoom.g:17492:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__ContinuationTransition__Group__5__Impl();
@@ -47775,21 +48434,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__5__Impl"
-    // InternalRoom.g:17270:1: rule__ContinuationTransition__Group__5__Impl : ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ;
+    // InternalRoom.g:17499:1: rule__ContinuationTransition__Group__5__Impl : ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ;
     public final void rule__ContinuationTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17274:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) )
-            // InternalRoom.g:17275:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17503:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:17504:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:17275:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
-            // InternalRoom.g:17276:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalRoom.g:17504:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17505:1: ( rule__ContinuationTransition__ToAssignment_5 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); 
-            // InternalRoom.g:17277:1: ( rule__ContinuationTransition__ToAssignment_5 )
-            // InternalRoom.g:17277:2: rule__ContinuationTransition__ToAssignment_5
+            // InternalRoom.g:17506:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalRoom.g:17506:2: rule__ContinuationTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ToAssignment_5();
@@ -47822,14 +48481,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__6"
-    // InternalRoom.g:17287:1: rule__ContinuationTransition__Group__6 : rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ;
+    // InternalRoom.g:17516:1: rule__ContinuationTransition__Group__6 : rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ;
     public final void rule__ContinuationTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17291:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 )
-            // InternalRoom.g:17292:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7
+            // InternalRoom.g:17520:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 )
+            // InternalRoom.g:17521:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__ContinuationTransition__Group__6__Impl();
@@ -47860,29 +48519,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__6__Impl"
-    // InternalRoom.g:17299:1: rule__ContinuationTransition__Group__6__Impl : ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:17528:1: rule__ContinuationTransition__Group__6__Impl : ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ;
     public final void rule__ContinuationTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17303:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) )
-            // InternalRoom.g:17304:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17532:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:17533:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:17304:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:17305:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            // InternalRoom.g:17533:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17534:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:17306:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
-            int alt172=2;
-            int LA172_0 = input.LA(1);
+            // InternalRoom.g:17535:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            int alt175=2;
+            int LA175_0 = input.LA(1);
 
-            if ( (LA172_0==62) ) {
-                alt172=1;
+            if ( (LA175_0==62) ) {
+                alt175=1;
             }
-            switch (alt172) {
+            switch (alt175) {
                 case 1 :
-                    // InternalRoom.g:17306:2: rule__ContinuationTransition__DocuAssignment_6
+                    // InternalRoom.g:17535:2: rule__ContinuationTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__DocuAssignment_6();
@@ -47918,14 +48577,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__7"
-    // InternalRoom.g:17316:1: rule__ContinuationTransition__Group__7 : rule__ContinuationTransition__Group__7__Impl ;
+    // InternalRoom.g:17545:1: rule__ContinuationTransition__Group__7 : rule__ContinuationTransition__Group__7__Impl ;
     public final void rule__ContinuationTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17320:1: ( rule__ContinuationTransition__Group__7__Impl )
-            // InternalRoom.g:17321:2: rule__ContinuationTransition__Group__7__Impl
+            // InternalRoom.g:17549:1: ( rule__ContinuationTransition__Group__7__Impl )
+            // InternalRoom.g:17550:2: rule__ContinuationTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__7__Impl();
@@ -47951,29 +48610,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__7__Impl"
-    // InternalRoom.g:17327:1: rule__ContinuationTransition__Group__7__Impl : ( ( rule__ContinuationTransition__Group_7__0 )? ) ;
+    // InternalRoom.g:17556:1: rule__ContinuationTransition__Group__7__Impl : ( ( rule__ContinuationTransition__Group_7__0 )? ) ;
     public final void rule__ContinuationTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17331:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) )
-            // InternalRoom.g:17332:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
+            // InternalRoom.g:17560:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) )
+            // InternalRoom.g:17561:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
             {
-            // InternalRoom.g:17332:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
-            // InternalRoom.g:17333:1: ( rule__ContinuationTransition__Group_7__0 )?
+            // InternalRoom.g:17561:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
+            // InternalRoom.g:17562:1: ( rule__ContinuationTransition__Group_7__0 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup_7()); 
-            // InternalRoom.g:17334:1: ( rule__ContinuationTransition__Group_7__0 )?
-            int alt173=2;
-            int LA173_0 = input.LA(1);
+            // InternalRoom.g:17563:1: ( rule__ContinuationTransition__Group_7__0 )?
+            int alt176=2;
+            int LA176_0 = input.LA(1);
 
-            if ( (LA173_0==44) ) {
-                alt173=1;
+            if ( (LA176_0==44) ) {
+                alt176=1;
             }
-            switch (alt173) {
+            switch (alt176) {
                 case 1 :
-                    // InternalRoom.g:17334:2: rule__ContinuationTransition__Group_7__0
+                    // InternalRoom.g:17563:2: rule__ContinuationTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7__0();
@@ -48009,16 +48668,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__0"
-    // InternalRoom.g:17360:1: rule__ContinuationTransition__Group_7__0 : rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ;
+    // InternalRoom.g:17589:1: rule__ContinuationTransition__Group_7__0 : rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ;
     public final void rule__ContinuationTransition__Group_7__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17364:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 )
-            // InternalRoom.g:17365:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1
+            // InternalRoom.g:17593:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 )
+            // InternalRoom.g:17594:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__ContinuationTransition__Group_7__0__Impl();
 
             state._fsp--;
@@ -48047,17 +48706,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__0__Impl"
-    // InternalRoom.g:17372:1: rule__ContinuationTransition__Group_7__0__Impl : ( '{' ) ;
+    // InternalRoom.g:17601:1: rule__ContinuationTransition__Group_7__0__Impl : ( '{' ) ;
     public final void rule__ContinuationTransition__Group_7__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17376:1: ( ( '{' ) )
-            // InternalRoom.g:17377:1: ( '{' )
+            // InternalRoom.g:17605:1: ( ( '{' ) )
+            // InternalRoom.g:17606:1: ( '{' )
             {
-            // InternalRoom.g:17377:1: ( '{' )
-            // InternalRoom.g:17378:1: '{'
+            // InternalRoom.g:17606:1: ( '{' )
+            // InternalRoom.g:17607:1: '{'
             {
              before(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,44,FOLLOW_2); 
@@ -48084,16 +48743,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__1"
-    // InternalRoom.g:17391:1: rule__ContinuationTransition__Group_7__1 : rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ;
+    // InternalRoom.g:17620:1: rule__ContinuationTransition__Group_7__1 : rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ;
     public final void rule__ContinuationTransition__Group_7__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17395:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 )
-            // InternalRoom.g:17396:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2
+            // InternalRoom.g:17624:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 )
+            // InternalRoom.g:17625:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__ContinuationTransition__Group_7__1__Impl();
 
             state._fsp--;
@@ -48122,29 +48781,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__1__Impl"
-    // InternalRoom.g:17403:1: rule__ContinuationTransition__Group_7__1__Impl : ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ;
+    // InternalRoom.g:17632:1: rule__ContinuationTransition__Group_7__1__Impl : ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ;
     public final void rule__ContinuationTransition__Group_7__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17407:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) )
-            // InternalRoom.g:17408:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17636:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) )
+            // InternalRoom.g:17637:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
             {
-            // InternalRoom.g:17408:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
-            // InternalRoom.g:17409:1: ( rule__ContinuationTransition__Group_7_1__0 )?
+            // InternalRoom.g:17637:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17638:1: ( rule__ContinuationTransition__Group_7_1__0 )?
             {
              before(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); 
-            // InternalRoom.g:17410:1: ( rule__ContinuationTransition__Group_7_1__0 )?
-            int alt174=2;
-            int LA174_0 = input.LA(1);
+            // InternalRoom.g:17639:1: ( rule__ContinuationTransition__Group_7_1__0 )?
+            int alt177=2;
+            int LA177_0 = input.LA(1);
 
-            if ( (LA174_0==107) ) {
-                alt174=1;
+            if ( (LA177_0==107) ) {
+                alt177=1;
             }
-            switch (alt174) {
+            switch (alt177) {
                 case 1 :
-                    // InternalRoom.g:17410:2: rule__ContinuationTransition__Group_7_1__0
+                    // InternalRoom.g:17639:2: rule__ContinuationTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7_1__0();
@@ -48180,14 +48839,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__2"
-    // InternalRoom.g:17420:1: rule__ContinuationTransition__Group_7__2 : rule__ContinuationTransition__Group_7__2__Impl ;
+    // InternalRoom.g:17649:1: rule__ContinuationTransition__Group_7__2 : rule__ContinuationTransition__Group_7__2__Impl ;
     public final void rule__ContinuationTransition__Group_7__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17424:1: ( rule__ContinuationTransition__Group_7__2__Impl )
-            // InternalRoom.g:17425:2: rule__ContinuationTransition__Group_7__2__Impl
+            // InternalRoom.g:17653:1: ( rule__ContinuationTransition__Group_7__2__Impl )
+            // InternalRoom.g:17654:2: rule__ContinuationTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7__2__Impl();
@@ -48213,17 +48872,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7__2__Impl"
-    // InternalRoom.g:17431:1: rule__ContinuationTransition__Group_7__2__Impl : ( '}' ) ;
+    // InternalRoom.g:17660:1: rule__ContinuationTransition__Group_7__2__Impl : ( '}' ) ;
     public final void rule__ContinuationTransition__Group_7__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17435:1: ( ( '}' ) )
-            // InternalRoom.g:17436:1: ( '}' )
+            // InternalRoom.g:17664:1: ( ( '}' ) )
+            // InternalRoom.g:17665:1: ( '}' )
             {
-            // InternalRoom.g:17436:1: ( '}' )
-            // InternalRoom.g:17437:1: '}'
+            // InternalRoom.g:17665:1: ( '}' )
+            // InternalRoom.g:17666:1: '}'
             {
              before(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,45,FOLLOW_2); 
@@ -48250,14 +48909,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__0"
-    // InternalRoom.g:17456:1: rule__ContinuationTransition__Group_7_1__0 : rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ;
+    // InternalRoom.g:17685:1: rule__ContinuationTransition__Group_7_1__0 : rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ;
     public final void rule__ContinuationTransition__Group_7_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17460:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 )
-            // InternalRoom.g:17461:2: rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1
+            // InternalRoom.g:17689:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 )
+            // InternalRoom.g:17690:2: rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1
             {
             pushFollow(FOLLOW_27);
             rule__ContinuationTransition__Group_7_1__0__Impl();
@@ -48288,17 +48947,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__0__Impl"
-    // InternalRoom.g:17468:1: rule__ContinuationTransition__Group_7_1__0__Impl : ( 'action' ) ;
+    // InternalRoom.g:17697:1: rule__ContinuationTransition__Group_7_1__0__Impl : ( 'action' ) ;
     public final void rule__ContinuationTransition__Group_7_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17472:1: ( ( 'action' ) )
-            // InternalRoom.g:17473:1: ( 'action' )
+            // InternalRoom.g:17701:1: ( ( 'action' ) )
+            // InternalRoom.g:17702:1: ( 'action' )
             {
-            // InternalRoom.g:17473:1: ( 'action' )
-            // InternalRoom.g:17474:1: 'action'
+            // InternalRoom.g:17702:1: ( 'action' )
+            // InternalRoom.g:17703:1: 'action'
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,107,FOLLOW_2); 
@@ -48325,14 +48984,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__1"
-    // InternalRoom.g:17487:1: rule__ContinuationTransition__Group_7_1__1 : rule__ContinuationTransition__Group_7_1__1__Impl ;
+    // InternalRoom.g:17716:1: rule__ContinuationTransition__Group_7_1__1 : rule__ContinuationTransition__Group_7_1__1__Impl ;
     public final void rule__ContinuationTransition__Group_7_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17491:1: ( rule__ContinuationTransition__Group_7_1__1__Impl )
-            // InternalRoom.g:17492:2: rule__ContinuationTransition__Group_7_1__1__Impl
+            // InternalRoom.g:17720:1: ( rule__ContinuationTransition__Group_7_1__1__Impl )
+            // InternalRoom.g:17721:2: rule__ContinuationTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7_1__1__Impl();
@@ -48358,21 +49017,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group_7_1__1__Impl"
-    // InternalRoom.g:17498:1: rule__ContinuationTransition__Group_7_1__1__Impl : ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ;
+    // InternalRoom.g:17727:1: rule__ContinuationTransition__Group_7_1__1__Impl : ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ;
     public final void rule__ContinuationTransition__Group_7_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17502:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) )
-            // InternalRoom.g:17503:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17731:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalRoom.g:17732:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
             {
-            // InternalRoom.g:17503:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
-            // InternalRoom.g:17504:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17732:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17733:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); 
-            // InternalRoom.g:17505:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
-            // InternalRoom.g:17505:2: rule__ContinuationTransition__ActionAssignment_7_1_1
+            // InternalRoom.g:17734:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17734:2: rule__ContinuationTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ActionAssignment_7_1_1();
@@ -48405,16 +49064,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__0"
-    // InternalRoom.g:17519:1: rule__TriggeredTransition__Group__0 : rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ;
+    // InternalRoom.g:17748:1: rule__TriggeredTransition__Group__0 : rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ;
     public final void rule__TriggeredTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17523:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 )
-            // InternalRoom.g:17524:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1
+            // InternalRoom.g:17752:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 )
+            // InternalRoom.g:17753:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__TriggeredTransition__Group__0__Impl();
 
             state._fsp--;
@@ -48443,17 +49102,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__0__Impl"
-    // InternalRoom.g:17531:1: rule__TriggeredTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalRoom.g:17760:1: rule__TriggeredTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__TriggeredTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17535:1: ( ( 'Transition' ) )
-            // InternalRoom.g:17536:1: ( 'Transition' )
+            // InternalRoom.g:17764:1: ( ( 'Transition' ) )
+            // InternalRoom.g:17765:1: ( 'Transition' )
             {
-            // InternalRoom.g:17536:1: ( 'Transition' )
-            // InternalRoom.g:17537:1: 'Transition'
+            // InternalRoom.g:17765:1: ( 'Transition' )
+            // InternalRoom.g:17766:1: 'Transition'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -48480,16 +49139,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__1"
-    // InternalRoom.g:17550:1: rule__TriggeredTransition__Group__1 : rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ;
+    // InternalRoom.g:17779:1: rule__TriggeredTransition__Group__1 : rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ;
     public final void rule__TriggeredTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17554:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 )
-            // InternalRoom.g:17555:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2
+            // InternalRoom.g:17783:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 )
+            // InternalRoom.g:17784:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__TriggeredTransition__Group__1__Impl();
 
             state._fsp--;
@@ -48518,29 +49177,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__1__Impl"
-    // InternalRoom.g:17562:1: rule__TriggeredTransition__Group__1__Impl : ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ;
+    // InternalRoom.g:17791:1: rule__TriggeredTransition__Group__1__Impl : ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ;
     public final void rule__TriggeredTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17566:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) )
-            // InternalRoom.g:17567:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17795:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:17796:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:17567:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
-            // InternalRoom.g:17568:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            // InternalRoom.g:17796:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17797:1: ( rule__TriggeredTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); 
-            // InternalRoom.g:17569:1: ( rule__TriggeredTransition__NameAssignment_1 )?
-            int alt175=2;
-            int LA175_0 = input.LA(1);
+            // InternalRoom.g:17798:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            int alt178=2;
+            int LA178_0 = input.LA(1);
 
-            if ( (LA175_0==RULE_ID) ) {
-                alt175=1;
+            if ( (LA178_0==RULE_ID) ) {
+                alt178=1;
             }
-            switch (alt175) {
+            switch (alt178) {
                 case 1 :
-                    // InternalRoom.g:17569:2: rule__TriggeredTransition__NameAssignment_1
+                    // InternalRoom.g:17798:2: rule__TriggeredTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__NameAssignment_1();
@@ -48576,16 +49235,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__2"
-    // InternalRoom.g:17579:1: rule__TriggeredTransition__Group__2 : rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ;
+    // InternalRoom.g:17808:1: rule__TriggeredTransition__Group__2 : rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ;
     public final void rule__TriggeredTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17583:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 )
-            // InternalRoom.g:17584:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3
+            // InternalRoom.g:17812:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 )
+            // InternalRoom.g:17813:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__TriggeredTransition__Group__2__Impl();
 
             state._fsp--;
@@ -48614,17 +49273,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__2__Impl"
-    // InternalRoom.g:17591:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:17820:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__TriggeredTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17595:1: ( ( ':' ) )
-            // InternalRoom.g:17596:1: ( ':' )
+            // InternalRoom.g:17824:1: ( ( ':' ) )
+            // InternalRoom.g:17825:1: ( ':' )
             {
-            // InternalRoom.g:17596:1: ( ':' )
-            // InternalRoom.g:17597:1: ':'
+            // InternalRoom.g:17825:1: ( ':' )
+            // InternalRoom.g:17826:1: ':'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -48651,14 +49310,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__3"
-    // InternalRoom.g:17610:1: rule__TriggeredTransition__Group__3 : rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ;
+    // InternalRoom.g:17839:1: rule__TriggeredTransition__Group__3 : rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ;
     public final void rule__TriggeredTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17614:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 )
-            // InternalRoom.g:17615:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4
+            // InternalRoom.g:17843:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 )
+            // InternalRoom.g:17844:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__TriggeredTransition__Group__3__Impl();
@@ -48689,21 +49348,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__3__Impl"
-    // InternalRoom.g:17622:1: rule__TriggeredTransition__Group__3__Impl : ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ;
+    // InternalRoom.g:17851:1: rule__TriggeredTransition__Group__3__Impl : ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ;
     public final void rule__TriggeredTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17626:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) )
-            // InternalRoom.g:17627:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17855:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:17856:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:17627:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
-            // InternalRoom.g:17628:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalRoom.g:17856:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17857:1: ( rule__TriggeredTransition__FromAssignment_3 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); 
-            // InternalRoom.g:17629:1: ( rule__TriggeredTransition__FromAssignment_3 )
-            // InternalRoom.g:17629:2: rule__TriggeredTransition__FromAssignment_3
+            // InternalRoom.g:17858:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalRoom.g:17858:2: rule__TriggeredTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__FromAssignment_3();
@@ -48736,16 +49395,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__4"
-    // InternalRoom.g:17639:1: rule__TriggeredTransition__Group__4 : rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ;
+    // InternalRoom.g:17868:1: rule__TriggeredTransition__Group__4 : rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ;
     public final void rule__TriggeredTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17643:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 )
-            // InternalRoom.g:17644:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5
+            // InternalRoom.g:17872:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 )
+            // InternalRoom.g:17873:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__TriggeredTransition__Group__4__Impl();
 
             state._fsp--;
@@ -48774,17 +49433,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__4__Impl"
-    // InternalRoom.g:17651:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:17880:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__TriggeredTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17655:1: ( ( '->' ) )
-            // InternalRoom.g:17656:1: ( '->' )
+            // InternalRoom.g:17884:1: ( ( '->' ) )
+            // InternalRoom.g:17885:1: ( '->' )
             {
-            // InternalRoom.g:17656:1: ( '->' )
-            // InternalRoom.g:17657:1: '->'
+            // InternalRoom.g:17885:1: ( '->' )
+            // InternalRoom.g:17886:1: '->'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -48811,14 +49470,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__5"
-    // InternalRoom.g:17670:1: rule__TriggeredTransition__Group__5 : rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ;
+    // InternalRoom.g:17899:1: rule__TriggeredTransition__Group__5 : rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ;
     public final void rule__TriggeredTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17674:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 )
-            // InternalRoom.g:17675:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6
+            // InternalRoom.g:17903:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 )
+            // InternalRoom.g:17904:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__TriggeredTransition__Group__5__Impl();
@@ -48849,21 +49508,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__5__Impl"
-    // InternalRoom.g:17682:1: rule__TriggeredTransition__Group__5__Impl : ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ;
+    // InternalRoom.g:17911:1: rule__TriggeredTransition__Group__5__Impl : ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ;
     public final void rule__TriggeredTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17686:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) )
-            // InternalRoom.g:17687:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17915:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:17916:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:17687:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
-            // InternalRoom.g:17688:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalRoom.g:17916:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17917:1: ( rule__TriggeredTransition__ToAssignment_5 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); 
-            // InternalRoom.g:17689:1: ( rule__TriggeredTransition__ToAssignment_5 )
-            // InternalRoom.g:17689:2: rule__TriggeredTransition__ToAssignment_5
+            // InternalRoom.g:17918:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalRoom.g:17918:2: rule__TriggeredTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ToAssignment_5();
@@ -48896,14 +49555,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__6"
-    // InternalRoom.g:17699:1: rule__TriggeredTransition__Group__6 : rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ;
+    // InternalRoom.g:17928:1: rule__TriggeredTransition__Group__6 : rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ;
     public final void rule__TriggeredTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17703:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 )
-            // InternalRoom.g:17704:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7
+            // InternalRoom.g:17932:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 )
+            // InternalRoom.g:17933:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__TriggeredTransition__Group__6__Impl();
@@ -48934,29 +49593,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__6__Impl"
-    // InternalRoom.g:17711:1: rule__TriggeredTransition__Group__6__Impl : ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:17940:1: rule__TriggeredTransition__Group__6__Impl : ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ;
     public final void rule__TriggeredTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17715:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) )
-            // InternalRoom.g:17716:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17944:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:17945:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:17716:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:17717:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            // InternalRoom.g:17945:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17946:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:17718:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
-            int alt176=2;
-            int LA176_0 = input.LA(1);
+            // InternalRoom.g:17947:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            int alt179=2;
+            int LA179_0 = input.LA(1);
 
-            if ( (LA176_0==62) ) {
-                alt176=1;
+            if ( (LA179_0==62) ) {
+                alt179=1;
             }
-            switch (alt176) {
+            switch (alt179) {
                 case 1 :
-                    // InternalRoom.g:17718:2: rule__TriggeredTransition__DocuAssignment_6
+                    // InternalRoom.g:17947:2: rule__TriggeredTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__DocuAssignment_6();
@@ -48992,16 +49651,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__7"
-    // InternalRoom.g:17728:1: rule__TriggeredTransition__Group__7 : rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ;
+    // InternalRoom.g:17957:1: rule__TriggeredTransition__Group__7 : rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ;
     public final void rule__TriggeredTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17732:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 )
-            // InternalRoom.g:17733:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8
+            // InternalRoom.g:17961:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 )
+            // InternalRoom.g:17962:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8
             {
-            pushFollow(FOLLOW_90);
+            pushFollow(FOLLOW_91);
             rule__TriggeredTransition__Group__7__Impl();
 
             state._fsp--;
@@ -49030,17 +49689,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__7__Impl"
-    // InternalRoom.g:17740:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:17969:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__TriggeredTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17744:1: ( ( '{' ) )
-            // InternalRoom.g:17745:1: ( '{' )
+            // InternalRoom.g:17973:1: ( ( '{' ) )
+            // InternalRoom.g:17974:1: ( '{' )
             {
-            // InternalRoom.g:17745:1: ( '{' )
-            // InternalRoom.g:17746:1: '{'
+            // InternalRoom.g:17974:1: ( '{' )
+            // InternalRoom.g:17975:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -49067,14 +49726,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__8"
-    // InternalRoom.g:17759:1: rule__TriggeredTransition__Group__8 : rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ;
+    // InternalRoom.g:17988:1: rule__TriggeredTransition__Group__8 : rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ;
     public final void rule__TriggeredTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17763:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 )
-            // InternalRoom.g:17764:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9
+            // InternalRoom.g:17992:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 )
+            // InternalRoom.g:17993:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9
             {
             pushFollow(FOLLOW_40);
             rule__TriggeredTransition__Group__8__Impl();
@@ -49105,17 +49764,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__8__Impl"
-    // InternalRoom.g:17771:1: rule__TriggeredTransition__Group__8__Impl : ( 'triggers' ) ;
+    // InternalRoom.g:18000:1: rule__TriggeredTransition__Group__8__Impl : ( 'triggers' ) ;
     public final void rule__TriggeredTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17775:1: ( ( 'triggers' ) )
-            // InternalRoom.g:17776:1: ( 'triggers' )
+            // InternalRoom.g:18004:1: ( ( 'triggers' ) )
+            // InternalRoom.g:18005:1: ( 'triggers' )
             {
-            // InternalRoom.g:17776:1: ( 'triggers' )
-            // InternalRoom.g:17777:1: 'triggers'
+            // InternalRoom.g:18005:1: ( 'triggers' )
+            // InternalRoom.g:18006:1: 'triggers'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); 
             match(input,108,FOLLOW_2); 
@@ -49142,16 +49801,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__9"
-    // InternalRoom.g:17790:1: rule__TriggeredTransition__Group__9 : rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ;
+    // InternalRoom.g:18019:1: rule__TriggeredTransition__Group__9 : rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ;
     public final void rule__TriggeredTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17794:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 )
-            // InternalRoom.g:17795:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10
+            // InternalRoom.g:18023:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 )
+            // InternalRoom.g:18024:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10
             {
-            pushFollow(FOLLOW_91);
+            pushFollow(FOLLOW_92);
             rule__TriggeredTransition__Group__9__Impl();
 
             state._fsp--;
@@ -49180,17 +49839,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__9__Impl"
-    // InternalRoom.g:17802:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ;
+    // InternalRoom.g:18031:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ;
     public final void rule__TriggeredTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17806:1: ( ( '{' ) )
-            // InternalRoom.g:17807:1: ( '{' )
+            // InternalRoom.g:18035:1: ( ( '{' ) )
+            // InternalRoom.g:18036:1: ( '{' )
             {
-            // InternalRoom.g:17807:1: ( '{' )
-            // InternalRoom.g:17808:1: '{'
+            // InternalRoom.g:18036:1: ( '{' )
+            // InternalRoom.g:18037:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); 
             match(input,44,FOLLOW_2); 
@@ -49217,16 +49876,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__10"
-    // InternalRoom.g:17821:1: rule__TriggeredTransition__Group__10 : rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ;
+    // InternalRoom.g:18050:1: rule__TriggeredTransition__Group__10 : rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ;
     public final void rule__TriggeredTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17825:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 )
-            // InternalRoom.g:17826:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11
+            // InternalRoom.g:18054:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 )
+            // InternalRoom.g:18055:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11
             {
-            pushFollow(FOLLOW_92);
+            pushFollow(FOLLOW_93);
             rule__TriggeredTransition__Group__10__Impl();
 
             state._fsp--;
@@ -49255,21 +49914,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__10__Impl"
-    // InternalRoom.g:17833:1: rule__TriggeredTransition__Group__10__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ;
+    // InternalRoom.g:18062:1: rule__TriggeredTransition__Group__10__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ;
     public final void rule__TriggeredTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17837:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) )
-            // InternalRoom.g:17838:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
+            // InternalRoom.g:18066:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) )
+            // InternalRoom.g:18067:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
             {
-            // InternalRoom.g:17838:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
-            // InternalRoom.g:17839:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalRoom.g:18067:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
+            // InternalRoom.g:18068:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); 
-            // InternalRoom.g:17840:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
-            // InternalRoom.g:17840:2: rule__TriggeredTransition__TriggersAssignment_10
+            // InternalRoom.g:18069:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalRoom.g:18069:2: rule__TriggeredTransition__TriggersAssignment_10
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_10();
@@ -49302,16 +49961,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__11"
-    // InternalRoom.g:17850:1: rule__TriggeredTransition__Group__11 : rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ;
+    // InternalRoom.g:18079:1: rule__TriggeredTransition__Group__11 : rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ;
     public final void rule__TriggeredTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17854:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 )
-            // InternalRoom.g:17855:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12
+            // InternalRoom.g:18083:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 )
+            // InternalRoom.g:18084:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12
             {
-            pushFollow(FOLLOW_92);
+            pushFollow(FOLLOW_93);
             rule__TriggeredTransition__Group__11__Impl();
 
             state._fsp--;
@@ -49340,35 +49999,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__11__Impl"
-    // InternalRoom.g:17862:1: rule__TriggeredTransition__Group__11__Impl : ( ( rule__TriggeredTransition__Group_11__0 )* ) ;
+    // InternalRoom.g:18091:1: rule__TriggeredTransition__Group__11__Impl : ( ( rule__TriggeredTransition__Group_11__0 )* ) ;
     public final void rule__TriggeredTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17866:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) )
-            // InternalRoom.g:17867:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
+            // InternalRoom.g:18095:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) )
+            // InternalRoom.g:18096:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
             {
-            // InternalRoom.g:17867:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
-            // InternalRoom.g:17868:1: ( rule__TriggeredTransition__Group_11__0 )*
+            // InternalRoom.g:18096:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
+            // InternalRoom.g:18097:1: ( rule__TriggeredTransition__Group_11__0 )*
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); 
-            // InternalRoom.g:17869:1: ( rule__TriggeredTransition__Group_11__0 )*
-            loop177:
+            // InternalRoom.g:18098:1: ( rule__TriggeredTransition__Group_11__0 )*
+            loop180:
             do {
-                int alt177=2;
-                int LA177_0 = input.LA(1);
+                int alt180=2;
+                int LA180_0 = input.LA(1);
 
-                if ( (LA177_0==109) ) {
-                    alt177=1;
+                if ( (LA180_0==109) ) {
+                    alt180=1;
                 }
 
 
-                switch (alt177) {
+                switch (alt180) {
             	case 1 :
-            	    // InternalRoom.g:17869:2: rule__TriggeredTransition__Group_11__0
+            	    // InternalRoom.g:18098:2: rule__TriggeredTransition__Group_11__0
             	    {
-            	    pushFollow(FOLLOW_93);
+            	    pushFollow(FOLLOW_94);
             	    rule__TriggeredTransition__Group_11__0();
 
             	    state._fsp--;
@@ -49378,7 +50037,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop177;
+            	    break loop180;
                 }
             } while (true);
 
@@ -49405,16 +50064,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__12"
-    // InternalRoom.g:17879:1: rule__TriggeredTransition__Group__12 : rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ;
+    // InternalRoom.g:18108:1: rule__TriggeredTransition__Group__12 : rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ;
     public final void rule__TriggeredTransition__Group__12() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17883:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 )
-            // InternalRoom.g:17884:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13
+            // InternalRoom.g:18112:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 )
+            // InternalRoom.g:18113:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__TriggeredTransition__Group__12__Impl();
 
             state._fsp--;
@@ -49443,17 +50102,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__12__Impl"
-    // InternalRoom.g:17891:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ;
+    // InternalRoom.g:18120:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ;
     public final void rule__TriggeredTransition__Group__12__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17895:1: ( ( '}' ) )
-            // InternalRoom.g:17896:1: ( '}' )
+            // InternalRoom.g:18124:1: ( ( '}' ) )
+            // InternalRoom.g:18125:1: ( '}' )
             {
-            // InternalRoom.g:17896:1: ( '}' )
-            // InternalRoom.g:17897:1: '}'
+            // InternalRoom.g:18125:1: ( '}' )
+            // InternalRoom.g:18126:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); 
             match(input,45,FOLLOW_2); 
@@ -49480,16 +50139,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__13"
-    // InternalRoom.g:17910:1: rule__TriggeredTransition__Group__13 : rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ;
+    // InternalRoom.g:18139:1: rule__TriggeredTransition__Group__13 : rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ;
     public final void rule__TriggeredTransition__Group__13() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17914:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 )
-            // InternalRoom.g:17915:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14
+            // InternalRoom.g:18143:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 )
+            // InternalRoom.g:18144:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__TriggeredTransition__Group__13__Impl();
 
             state._fsp--;
@@ -49518,29 +50177,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__13__Impl"
-    // InternalRoom.g:17922:1: rule__TriggeredTransition__Group__13__Impl : ( ( rule__TriggeredTransition__Group_13__0 )? ) ;
+    // InternalRoom.g:18151:1: rule__TriggeredTransition__Group__13__Impl : ( ( rule__TriggeredTransition__Group_13__0 )? ) ;
     public final void rule__TriggeredTransition__Group__13__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17926:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) )
-            // InternalRoom.g:17927:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
+            // InternalRoom.g:18155:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) )
+            // InternalRoom.g:18156:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
             {
-            // InternalRoom.g:17927:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
-            // InternalRoom.g:17928:1: ( rule__TriggeredTransition__Group_13__0 )?
+            // InternalRoom.g:18156:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
+            // InternalRoom.g:18157:1: ( rule__TriggeredTransition__Group_13__0 )?
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); 
-            // InternalRoom.g:17929:1: ( rule__TriggeredTransition__Group_13__0 )?
-            int alt178=2;
-            int LA178_0 = input.LA(1);
+            // InternalRoom.g:18158:1: ( rule__TriggeredTransition__Group_13__0 )?
+            int alt181=2;
+            int LA181_0 = input.LA(1);
 
-            if ( (LA178_0==107) ) {
-                alt178=1;
+            if ( (LA181_0==107) ) {
+                alt181=1;
             }
-            switch (alt178) {
+            switch (alt181) {
                 case 1 :
-                    // InternalRoom.g:17929:2: rule__TriggeredTransition__Group_13__0
+                    // InternalRoom.g:18158:2: rule__TriggeredTransition__Group_13__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__Group_13__0();
@@ -49576,14 +50235,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__14"
-    // InternalRoom.g:17939:1: rule__TriggeredTransition__Group__14 : rule__TriggeredTransition__Group__14__Impl ;
+    // InternalRoom.g:18168:1: rule__TriggeredTransition__Group__14 : rule__TriggeredTransition__Group__14__Impl ;
     public final void rule__TriggeredTransition__Group__14() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17943:1: ( rule__TriggeredTransition__Group__14__Impl )
-            // InternalRoom.g:17944:2: rule__TriggeredTransition__Group__14__Impl
+            // InternalRoom.g:18172:1: ( rule__TriggeredTransition__Group__14__Impl )
+            // InternalRoom.g:18173:2: rule__TriggeredTransition__Group__14__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__14__Impl();
@@ -49609,17 +50268,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__14__Impl"
-    // InternalRoom.g:17950:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ;
+    // InternalRoom.g:18179:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ;
     public final void rule__TriggeredTransition__Group__14__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:17954:1: ( ( '}' ) )
-            // InternalRoom.g:17955:1: ( '}' )
+            // InternalRoom.g:18183:1: ( ( '}' ) )
+            // InternalRoom.g:18184:1: ( '}' )
             {
-            // InternalRoom.g:17955:1: ( '}' )
-            // InternalRoom.g:17956:1: '}'
+            // InternalRoom.g:18184:1: ( '}' )
+            // InternalRoom.g:18185:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); 
             match(input,45,FOLLOW_2); 
@@ -49646,16 +50305,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__0"
-    // InternalRoom.g:17999:1: rule__TriggeredTransition__Group_11__0 : rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ;
+    // InternalRoom.g:18228:1: rule__TriggeredTransition__Group_11__0 : rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ;
     public final void rule__TriggeredTransition__Group_11__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18003:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 )
-            // InternalRoom.g:18004:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1
+            // InternalRoom.g:18232:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 )
+            // InternalRoom.g:18233:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1
             {
-            pushFollow(FOLLOW_91);
+            pushFollow(FOLLOW_92);
             rule__TriggeredTransition__Group_11__0__Impl();
 
             state._fsp--;
@@ -49684,17 +50343,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__0__Impl"
-    // InternalRoom.g:18011:1: rule__TriggeredTransition__Group_11__0__Impl : ( 'or' ) ;
+    // InternalRoom.g:18240:1: rule__TriggeredTransition__Group_11__0__Impl : ( 'or' ) ;
     public final void rule__TriggeredTransition__Group_11__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18015:1: ( ( 'or' ) )
-            // InternalRoom.g:18016:1: ( 'or' )
+            // InternalRoom.g:18244:1: ( ( 'or' ) )
+            // InternalRoom.g:18245:1: ( 'or' )
             {
-            // InternalRoom.g:18016:1: ( 'or' )
-            // InternalRoom.g:18017:1: 'or'
+            // InternalRoom.g:18245:1: ( 'or' )
+            // InternalRoom.g:18246:1: 'or'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); 
             match(input,109,FOLLOW_2); 
@@ -49721,14 +50380,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__1"
-    // InternalRoom.g:18030:1: rule__TriggeredTransition__Group_11__1 : rule__TriggeredTransition__Group_11__1__Impl ;
+    // InternalRoom.g:18259:1: rule__TriggeredTransition__Group_11__1 : rule__TriggeredTransition__Group_11__1__Impl ;
     public final void rule__TriggeredTransition__Group_11__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18034:1: ( rule__TriggeredTransition__Group_11__1__Impl )
-            // InternalRoom.g:18035:2: rule__TriggeredTransition__Group_11__1__Impl
+            // InternalRoom.g:18263:1: ( rule__TriggeredTransition__Group_11__1__Impl )
+            // InternalRoom.g:18264:2: rule__TriggeredTransition__Group_11__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_11__1__Impl();
@@ -49754,21 +50413,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_11__1__Impl"
-    // InternalRoom.g:18041:1: rule__TriggeredTransition__Group_11__1__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ;
+    // InternalRoom.g:18270:1: rule__TriggeredTransition__Group_11__1__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ;
     public final void rule__TriggeredTransition__Group_11__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18045:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) )
-            // InternalRoom.g:18046:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
+            // InternalRoom.g:18274:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) )
+            // InternalRoom.g:18275:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
             {
-            // InternalRoom.g:18046:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
-            // InternalRoom.g:18047:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
+            // InternalRoom.g:18275:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
+            // InternalRoom.g:18276:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); 
-            // InternalRoom.g:18048:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
-            // InternalRoom.g:18048:2: rule__TriggeredTransition__TriggersAssignment_11_1
+            // InternalRoom.g:18277:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
+            // InternalRoom.g:18277:2: rule__TriggeredTransition__TriggersAssignment_11_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_11_1();
@@ -49801,14 +50460,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__0"
-    // InternalRoom.g:18062:1: rule__TriggeredTransition__Group_13__0 : rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ;
+    // InternalRoom.g:18291:1: rule__TriggeredTransition__Group_13__0 : rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ;
     public final void rule__TriggeredTransition__Group_13__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18066:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 )
-            // InternalRoom.g:18067:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1
+            // InternalRoom.g:18295:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 )
+            // InternalRoom.g:18296:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1
             {
             pushFollow(FOLLOW_27);
             rule__TriggeredTransition__Group_13__0__Impl();
@@ -49839,17 +50498,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__0__Impl"
-    // InternalRoom.g:18074:1: rule__TriggeredTransition__Group_13__0__Impl : ( 'action' ) ;
+    // InternalRoom.g:18303:1: rule__TriggeredTransition__Group_13__0__Impl : ( 'action' ) ;
     public final void rule__TriggeredTransition__Group_13__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18078:1: ( ( 'action' ) )
-            // InternalRoom.g:18079:1: ( 'action' )
+            // InternalRoom.g:18307:1: ( ( 'action' ) )
+            // InternalRoom.g:18308:1: ( 'action' )
             {
-            // InternalRoom.g:18079:1: ( 'action' )
-            // InternalRoom.g:18080:1: 'action'
+            // InternalRoom.g:18308:1: ( 'action' )
+            // InternalRoom.g:18309:1: 'action'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); 
             match(input,107,FOLLOW_2); 
@@ -49876,14 +50535,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__1"
-    // InternalRoom.g:18093:1: rule__TriggeredTransition__Group_13__1 : rule__TriggeredTransition__Group_13__1__Impl ;
+    // InternalRoom.g:18322:1: rule__TriggeredTransition__Group_13__1 : rule__TriggeredTransition__Group_13__1__Impl ;
     public final void rule__TriggeredTransition__Group_13__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18097:1: ( rule__TriggeredTransition__Group_13__1__Impl )
-            // InternalRoom.g:18098:2: rule__TriggeredTransition__Group_13__1__Impl
+            // InternalRoom.g:18326:1: ( rule__TriggeredTransition__Group_13__1__Impl )
+            // InternalRoom.g:18327:2: rule__TriggeredTransition__Group_13__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_13__1__Impl();
@@ -49909,21 +50568,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group_13__1__Impl"
-    // InternalRoom.g:18104:1: rule__TriggeredTransition__Group_13__1__Impl : ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ;
+    // InternalRoom.g:18333:1: rule__TriggeredTransition__Group_13__1__Impl : ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ;
     public final void rule__TriggeredTransition__Group_13__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18108:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) )
-            // InternalRoom.g:18109:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
+            // InternalRoom.g:18337:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) )
+            // InternalRoom.g:18338:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
             {
-            // InternalRoom.g:18109:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
-            // InternalRoom.g:18110:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
+            // InternalRoom.g:18338:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
+            // InternalRoom.g:18339:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); 
-            // InternalRoom.g:18111:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
-            // InternalRoom.g:18111:2: rule__TriggeredTransition__ActionAssignment_13_1
+            // InternalRoom.g:18340:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
+            // InternalRoom.g:18340:2: rule__TriggeredTransition__ActionAssignment_13_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ActionAssignment_13_1();
@@ -49956,16 +50615,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__0"
-    // InternalRoom.g:18125:1: rule__GuardedTransition__Group__0 : rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ;
+    // InternalRoom.g:18354:1: rule__GuardedTransition__Group__0 : rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ;
     public final void rule__GuardedTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18129:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 )
-            // InternalRoom.g:18130:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1
+            // InternalRoom.g:18358:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 )
+            // InternalRoom.g:18359:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__GuardedTransition__Group__0__Impl();
 
             state._fsp--;
@@ -49994,17 +50653,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__0__Impl"
-    // InternalRoom.g:18137:1: rule__GuardedTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalRoom.g:18366:1: rule__GuardedTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__GuardedTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18141:1: ( ( 'Transition' ) )
-            // InternalRoom.g:18142:1: ( 'Transition' )
+            // InternalRoom.g:18370:1: ( ( 'Transition' ) )
+            // InternalRoom.g:18371:1: ( 'Transition' )
             {
-            // InternalRoom.g:18142:1: ( 'Transition' )
-            // InternalRoom.g:18143:1: 'Transition'
+            // InternalRoom.g:18371:1: ( 'Transition' )
+            // InternalRoom.g:18372:1: 'Transition'
             {
              before(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -50031,16 +50690,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__1"
-    // InternalRoom.g:18156:1: rule__GuardedTransition__Group__1 : rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ;
+    // InternalRoom.g:18385:1: rule__GuardedTransition__Group__1 : rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ;
     public final void rule__GuardedTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18160:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 )
-            // InternalRoom.g:18161:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2
+            // InternalRoom.g:18389:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 )
+            // InternalRoom.g:18390:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__GuardedTransition__Group__1__Impl();
 
             state._fsp--;
@@ -50069,29 +50728,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__1__Impl"
-    // InternalRoom.g:18168:1: rule__GuardedTransition__Group__1__Impl : ( ( rule__GuardedTransition__NameAssignment_1 )? ) ;
+    // InternalRoom.g:18397:1: rule__GuardedTransition__Group__1__Impl : ( ( rule__GuardedTransition__NameAssignment_1 )? ) ;
     public final void rule__GuardedTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18172:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) )
-            // InternalRoom.g:18173:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18401:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:18402:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:18173:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
-            // InternalRoom.g:18174:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            // InternalRoom.g:18402:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18403:1: ( rule__GuardedTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); 
-            // InternalRoom.g:18175:1: ( rule__GuardedTransition__NameAssignment_1 )?
-            int alt179=2;
-            int LA179_0 = input.LA(1);
+            // InternalRoom.g:18404:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            int alt182=2;
+            int LA182_0 = input.LA(1);
 
-            if ( (LA179_0==RULE_ID) ) {
-                alt179=1;
+            if ( (LA182_0==RULE_ID) ) {
+                alt182=1;
             }
-            switch (alt179) {
+            switch (alt182) {
                 case 1 :
-                    // InternalRoom.g:18175:2: rule__GuardedTransition__NameAssignment_1
+                    // InternalRoom.g:18404:2: rule__GuardedTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__NameAssignment_1();
@@ -50127,16 +50786,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__2"
-    // InternalRoom.g:18185:1: rule__GuardedTransition__Group__2 : rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ;
+    // InternalRoom.g:18414:1: rule__GuardedTransition__Group__2 : rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ;
     public final void rule__GuardedTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18189:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 )
-            // InternalRoom.g:18190:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3
+            // InternalRoom.g:18418:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 )
+            // InternalRoom.g:18419:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__GuardedTransition__Group__2__Impl();
 
             state._fsp--;
@@ -50165,17 +50824,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__2__Impl"
-    // InternalRoom.g:18197:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:18426:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__GuardedTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18201:1: ( ( ':' ) )
-            // InternalRoom.g:18202:1: ( ':' )
+            // InternalRoom.g:18430:1: ( ( ':' ) )
+            // InternalRoom.g:18431:1: ( ':' )
             {
-            // InternalRoom.g:18202:1: ( ':' )
-            // InternalRoom.g:18203:1: ':'
+            // InternalRoom.g:18431:1: ( ':' )
+            // InternalRoom.g:18432:1: ':'
             {
              before(grammarAccess.getGuardedTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -50202,14 +50861,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__3"
-    // InternalRoom.g:18216:1: rule__GuardedTransition__Group__3 : rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ;
+    // InternalRoom.g:18445:1: rule__GuardedTransition__Group__3 : rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ;
     public final void rule__GuardedTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18220:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 )
-            // InternalRoom.g:18221:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4
+            // InternalRoom.g:18449:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 )
+            // InternalRoom.g:18450:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__GuardedTransition__Group__3__Impl();
@@ -50240,21 +50899,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__3__Impl"
-    // InternalRoom.g:18228:1: rule__GuardedTransition__Group__3__Impl : ( ( rule__GuardedTransition__FromAssignment_3 ) ) ;
+    // InternalRoom.g:18457:1: rule__GuardedTransition__Group__3__Impl : ( ( rule__GuardedTransition__FromAssignment_3 ) ) ;
     public final void rule__GuardedTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18232:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) )
-            // InternalRoom.g:18233:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18461:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:18462:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:18233:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
-            // InternalRoom.g:18234:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalRoom.g:18462:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18463:1: ( rule__GuardedTransition__FromAssignment_3 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); 
-            // InternalRoom.g:18235:1: ( rule__GuardedTransition__FromAssignment_3 )
-            // InternalRoom.g:18235:2: rule__GuardedTransition__FromAssignment_3
+            // InternalRoom.g:18464:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalRoom.g:18464:2: rule__GuardedTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__FromAssignment_3();
@@ -50287,16 +50946,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__4"
-    // InternalRoom.g:18245:1: rule__GuardedTransition__Group__4 : rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ;
+    // InternalRoom.g:18474:1: rule__GuardedTransition__Group__4 : rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ;
     public final void rule__GuardedTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18249:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 )
-            // InternalRoom.g:18250:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5
+            // InternalRoom.g:18478:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 )
+            // InternalRoom.g:18479:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__GuardedTransition__Group__4__Impl();
 
             state._fsp--;
@@ -50325,17 +50984,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__4__Impl"
-    // InternalRoom.g:18257:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:18486:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__GuardedTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18261:1: ( ( '->' ) )
-            // InternalRoom.g:18262:1: ( '->' )
+            // InternalRoom.g:18490:1: ( ( '->' ) )
+            // InternalRoom.g:18491:1: ( '->' )
             {
-            // InternalRoom.g:18262:1: ( '->' )
-            // InternalRoom.g:18263:1: '->'
+            // InternalRoom.g:18491:1: ( '->' )
+            // InternalRoom.g:18492:1: '->'
             {
              before(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -50362,14 +51021,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__5"
-    // InternalRoom.g:18276:1: rule__GuardedTransition__Group__5 : rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ;
+    // InternalRoom.g:18505:1: rule__GuardedTransition__Group__5 : rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ;
     public final void rule__GuardedTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18280:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 )
-            // InternalRoom.g:18281:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6
+            // InternalRoom.g:18509:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 )
+            // InternalRoom.g:18510:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__GuardedTransition__Group__5__Impl();
@@ -50400,21 +51059,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__5__Impl"
-    // InternalRoom.g:18288:1: rule__GuardedTransition__Group__5__Impl : ( ( rule__GuardedTransition__ToAssignment_5 ) ) ;
+    // InternalRoom.g:18517:1: rule__GuardedTransition__Group__5__Impl : ( ( rule__GuardedTransition__ToAssignment_5 ) ) ;
     public final void rule__GuardedTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18292:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) )
-            // InternalRoom.g:18293:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18521:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:18522:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:18293:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
-            // InternalRoom.g:18294:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalRoom.g:18522:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18523:1: ( rule__GuardedTransition__ToAssignment_5 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); 
-            // InternalRoom.g:18295:1: ( rule__GuardedTransition__ToAssignment_5 )
-            // InternalRoom.g:18295:2: rule__GuardedTransition__ToAssignment_5
+            // InternalRoom.g:18524:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalRoom.g:18524:2: rule__GuardedTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ToAssignment_5();
@@ -50447,14 +51106,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__6"
-    // InternalRoom.g:18305:1: rule__GuardedTransition__Group__6 : rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ;
+    // InternalRoom.g:18534:1: rule__GuardedTransition__Group__6 : rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ;
     public final void rule__GuardedTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18309:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 )
-            // InternalRoom.g:18310:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7
+            // InternalRoom.g:18538:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 )
+            // InternalRoom.g:18539:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__GuardedTransition__Group__6__Impl();
@@ -50485,29 +51144,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__6__Impl"
-    // InternalRoom.g:18317:1: rule__GuardedTransition__Group__6__Impl : ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:18546:1: rule__GuardedTransition__Group__6__Impl : ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ;
     public final void rule__GuardedTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18321:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) )
-            // InternalRoom.g:18322:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18550:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:18551:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:18322:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:18323:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            // InternalRoom.g:18551:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18552:1: ( rule__GuardedTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:18324:1: ( rule__GuardedTransition__DocuAssignment_6 )?
-            int alt180=2;
-            int LA180_0 = input.LA(1);
+            // InternalRoom.g:18553:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            int alt183=2;
+            int LA183_0 = input.LA(1);
 
-            if ( (LA180_0==62) ) {
-                alt180=1;
+            if ( (LA183_0==62) ) {
+                alt183=1;
             }
-            switch (alt180) {
+            switch (alt183) {
                 case 1 :
-                    // InternalRoom.g:18324:2: rule__GuardedTransition__DocuAssignment_6
+                    // InternalRoom.g:18553:2: rule__GuardedTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__DocuAssignment_6();
@@ -50543,16 +51202,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__7"
-    // InternalRoom.g:18334:1: rule__GuardedTransition__Group__7 : rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ;
+    // InternalRoom.g:18563:1: rule__GuardedTransition__Group__7 : rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ;
     public final void rule__GuardedTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18338:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 )
-            // InternalRoom.g:18339:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8
+            // InternalRoom.g:18567:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 )
+            // InternalRoom.g:18568:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8
             {
-            pushFollow(FOLLOW_94);
+            pushFollow(FOLLOW_95);
             rule__GuardedTransition__Group__7__Impl();
 
             state._fsp--;
@@ -50581,17 +51240,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__7__Impl"
-    // InternalRoom.g:18346:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:18575:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__GuardedTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18350:1: ( ( '{' ) )
-            // InternalRoom.g:18351:1: ( '{' )
+            // InternalRoom.g:18579:1: ( ( '{' ) )
+            // InternalRoom.g:18580:1: ( '{' )
             {
-            // InternalRoom.g:18351:1: ( '{' )
-            // InternalRoom.g:18352:1: '{'
+            // InternalRoom.g:18580:1: ( '{' )
+            // InternalRoom.g:18581:1: '{'
             {
              before(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -50618,14 +51277,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__8"
-    // InternalRoom.g:18365:1: rule__GuardedTransition__Group__8 : rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ;
+    // InternalRoom.g:18594:1: rule__GuardedTransition__Group__8 : rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ;
     public final void rule__GuardedTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18369:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 )
-            // InternalRoom.g:18370:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9
+            // InternalRoom.g:18598:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 )
+            // InternalRoom.g:18599:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9
             {
             pushFollow(FOLLOW_27);
             rule__GuardedTransition__Group__8__Impl();
@@ -50656,17 +51315,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__8__Impl"
-    // InternalRoom.g:18377:1: rule__GuardedTransition__Group__8__Impl : ( 'guard' ) ;
+    // InternalRoom.g:18606:1: rule__GuardedTransition__Group__8__Impl : ( 'guard' ) ;
     public final void rule__GuardedTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18381:1: ( ( 'guard' ) )
-            // InternalRoom.g:18382:1: ( 'guard' )
+            // InternalRoom.g:18610:1: ( ( 'guard' ) )
+            // InternalRoom.g:18611:1: ( 'guard' )
             {
-            // InternalRoom.g:18382:1: ( 'guard' )
-            // InternalRoom.g:18383:1: 'guard'
+            // InternalRoom.g:18611:1: ( 'guard' )
+            // InternalRoom.g:18612:1: 'guard'
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); 
             match(input,110,FOLLOW_2); 
@@ -50693,16 +51352,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__9"
-    // InternalRoom.g:18396:1: rule__GuardedTransition__Group__9 : rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ;
+    // InternalRoom.g:18625:1: rule__GuardedTransition__Group__9 : rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ;
     public final void rule__GuardedTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18400:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 )
-            // InternalRoom.g:18401:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10
+            // InternalRoom.g:18629:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 )
+            // InternalRoom.g:18630:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__GuardedTransition__Group__9__Impl();
 
             state._fsp--;
@@ -50731,21 +51390,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__9__Impl"
-    // InternalRoom.g:18408:1: rule__GuardedTransition__Group__9__Impl : ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ;
+    // InternalRoom.g:18637:1: rule__GuardedTransition__Group__9__Impl : ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ;
     public final void rule__GuardedTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18412:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) )
-            // InternalRoom.g:18413:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
+            // InternalRoom.g:18641:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) )
+            // InternalRoom.g:18642:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
             {
-            // InternalRoom.g:18413:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
-            // InternalRoom.g:18414:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalRoom.g:18642:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
+            // InternalRoom.g:18643:1: ( rule__GuardedTransition__GuardAssignment_9 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); 
-            // InternalRoom.g:18415:1: ( rule__GuardedTransition__GuardAssignment_9 )
-            // InternalRoom.g:18415:2: rule__GuardedTransition__GuardAssignment_9
+            // InternalRoom.g:18644:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalRoom.g:18644:2: rule__GuardedTransition__GuardAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__GuardAssignment_9();
@@ -50778,16 +51437,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__10"
-    // InternalRoom.g:18425:1: rule__GuardedTransition__Group__10 : rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ;
+    // InternalRoom.g:18654:1: rule__GuardedTransition__Group__10 : rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ;
     public final void rule__GuardedTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18429:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 )
-            // InternalRoom.g:18430:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11
+            // InternalRoom.g:18658:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 )
+            // InternalRoom.g:18659:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__GuardedTransition__Group__10__Impl();
 
             state._fsp--;
@@ -50816,29 +51475,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__10__Impl"
-    // InternalRoom.g:18437:1: rule__GuardedTransition__Group__10__Impl : ( ( rule__GuardedTransition__Group_10__0 )? ) ;
+    // InternalRoom.g:18666:1: rule__GuardedTransition__Group__10__Impl : ( ( rule__GuardedTransition__Group_10__0 )? ) ;
     public final void rule__GuardedTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18441:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) )
-            // InternalRoom.g:18442:1: ( ( rule__GuardedTransition__Group_10__0 )? )
+            // InternalRoom.g:18670:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) )
+            // InternalRoom.g:18671:1: ( ( rule__GuardedTransition__Group_10__0 )? )
             {
-            // InternalRoom.g:18442:1: ( ( rule__GuardedTransition__Group_10__0 )? )
-            // InternalRoom.g:18443:1: ( rule__GuardedTransition__Group_10__0 )?
+            // InternalRoom.g:18671:1: ( ( rule__GuardedTransition__Group_10__0 )? )
+            // InternalRoom.g:18672:1: ( rule__GuardedTransition__Group_10__0 )?
             {
              before(grammarAccess.getGuardedTransitionAccess().getGroup_10()); 
-            // InternalRoom.g:18444:1: ( rule__GuardedTransition__Group_10__0 )?
-            int alt181=2;
-            int LA181_0 = input.LA(1);
+            // InternalRoom.g:18673:1: ( rule__GuardedTransition__Group_10__0 )?
+            int alt184=2;
+            int LA184_0 = input.LA(1);
 
-            if ( (LA181_0==107) ) {
-                alt181=1;
+            if ( (LA184_0==107) ) {
+                alt184=1;
             }
-            switch (alt181) {
+            switch (alt184) {
                 case 1 :
-                    // InternalRoom.g:18444:2: rule__GuardedTransition__Group_10__0
+                    // InternalRoom.g:18673:2: rule__GuardedTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__Group_10__0();
@@ -50874,14 +51533,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__11"
-    // InternalRoom.g:18454:1: rule__GuardedTransition__Group__11 : rule__GuardedTransition__Group__11__Impl ;
+    // InternalRoom.g:18683:1: rule__GuardedTransition__Group__11 : rule__GuardedTransition__Group__11__Impl ;
     public final void rule__GuardedTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18458:1: ( rule__GuardedTransition__Group__11__Impl )
-            // InternalRoom.g:18459:2: rule__GuardedTransition__Group__11__Impl
+            // InternalRoom.g:18687:1: ( rule__GuardedTransition__Group__11__Impl )
+            // InternalRoom.g:18688:2: rule__GuardedTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__11__Impl();
@@ -50907,17 +51566,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__11__Impl"
-    // InternalRoom.g:18465:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ;
+    // InternalRoom.g:18694:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ;
     public final void rule__GuardedTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18469:1: ( ( '}' ) )
-            // InternalRoom.g:18470:1: ( '}' )
+            // InternalRoom.g:18698:1: ( ( '}' ) )
+            // InternalRoom.g:18699:1: ( '}' )
             {
-            // InternalRoom.g:18470:1: ( '}' )
-            // InternalRoom.g:18471:1: '}'
+            // InternalRoom.g:18699:1: ( '}' )
+            // InternalRoom.g:18700:1: '}'
             {
              before(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,45,FOLLOW_2); 
@@ -50944,14 +51603,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__0"
-    // InternalRoom.g:18508:1: rule__GuardedTransition__Group_10__0 : rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ;
+    // InternalRoom.g:18737:1: rule__GuardedTransition__Group_10__0 : rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ;
     public final void rule__GuardedTransition__Group_10__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18512:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 )
-            // InternalRoom.g:18513:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1
+            // InternalRoom.g:18741:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 )
+            // InternalRoom.g:18742:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1
             {
             pushFollow(FOLLOW_27);
             rule__GuardedTransition__Group_10__0__Impl();
@@ -50982,17 +51641,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__0__Impl"
-    // InternalRoom.g:18520:1: rule__GuardedTransition__Group_10__0__Impl : ( 'action' ) ;
+    // InternalRoom.g:18749:1: rule__GuardedTransition__Group_10__0__Impl : ( 'action' ) ;
     public final void rule__GuardedTransition__Group_10__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18524:1: ( ( 'action' ) )
-            // InternalRoom.g:18525:1: ( 'action' )
+            // InternalRoom.g:18753:1: ( ( 'action' ) )
+            // InternalRoom.g:18754:1: ( 'action' )
             {
-            // InternalRoom.g:18525:1: ( 'action' )
-            // InternalRoom.g:18526:1: 'action'
+            // InternalRoom.g:18754:1: ( 'action' )
+            // InternalRoom.g:18755:1: 'action'
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); 
             match(input,107,FOLLOW_2); 
@@ -51019,14 +51678,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__1"
-    // InternalRoom.g:18539:1: rule__GuardedTransition__Group_10__1 : rule__GuardedTransition__Group_10__1__Impl ;
+    // InternalRoom.g:18768:1: rule__GuardedTransition__Group_10__1 : rule__GuardedTransition__Group_10__1__Impl ;
     public final void rule__GuardedTransition__Group_10__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18543:1: ( rule__GuardedTransition__Group_10__1__Impl )
-            // InternalRoom.g:18544:2: rule__GuardedTransition__Group_10__1__Impl
+            // InternalRoom.g:18772:1: ( rule__GuardedTransition__Group_10__1__Impl )
+            // InternalRoom.g:18773:2: rule__GuardedTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group_10__1__Impl();
@@ -51052,21 +51711,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group_10__1__Impl"
-    // InternalRoom.g:18550:1: rule__GuardedTransition__Group_10__1__Impl : ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ;
+    // InternalRoom.g:18779:1: rule__GuardedTransition__Group_10__1__Impl : ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ;
     public final void rule__GuardedTransition__Group_10__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18554:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) )
-            // InternalRoom.g:18555:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:18783:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) )
+            // InternalRoom.g:18784:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
             {
-            // InternalRoom.g:18555:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
-            // InternalRoom.g:18556:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:18784:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:18785:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); 
-            // InternalRoom.g:18557:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
-            // InternalRoom.g:18557:2: rule__GuardedTransition__ActionAssignment_10_1
+            // InternalRoom.g:18786:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:18786:2: rule__GuardedTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ActionAssignment_10_1();
@@ -51099,16 +51758,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__0"
-    // InternalRoom.g:18571:1: rule__CPBranchTransition__Group__0 : rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ;
+    // InternalRoom.g:18800:1: rule__CPBranchTransition__Group__0 : rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ;
     public final void rule__CPBranchTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18575:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 )
-            // InternalRoom.g:18576:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1
+            // InternalRoom.g:18804:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 )
+            // InternalRoom.g:18805:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__CPBranchTransition__Group__0__Impl();
 
             state._fsp--;
@@ -51137,17 +51796,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__0__Impl"
-    // InternalRoom.g:18583:1: rule__CPBranchTransition__Group__0__Impl : ( 'Transition' ) ;
+    // InternalRoom.g:18812:1: rule__CPBranchTransition__Group__0__Impl : ( 'Transition' ) ;
     public final void rule__CPBranchTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18587:1: ( ( 'Transition' ) )
-            // InternalRoom.g:18588:1: ( 'Transition' )
+            // InternalRoom.g:18816:1: ( ( 'Transition' ) )
+            // InternalRoom.g:18817:1: ( 'Transition' )
             {
-            // InternalRoom.g:18588:1: ( 'Transition' )
-            // InternalRoom.g:18589:1: 'Transition'
+            // InternalRoom.g:18817:1: ( 'Transition' )
+            // InternalRoom.g:18818:1: 'Transition'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -51174,16 +51833,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__1"
-    // InternalRoom.g:18602:1: rule__CPBranchTransition__Group__1 : rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ;
+    // InternalRoom.g:18831:1: rule__CPBranchTransition__Group__1 : rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ;
     public final void rule__CPBranchTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18606:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 )
-            // InternalRoom.g:18607:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2
+            // InternalRoom.g:18835:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 )
+            // InternalRoom.g:18836:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2
             {
-            pushFollow(FOLLOW_86);
+            pushFollow(FOLLOW_87);
             rule__CPBranchTransition__Group__1__Impl();
 
             state._fsp--;
@@ -51212,29 +51871,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__1__Impl"
-    // InternalRoom.g:18614:1: rule__CPBranchTransition__Group__1__Impl : ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ;
+    // InternalRoom.g:18843:1: rule__CPBranchTransition__Group__1__Impl : ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ;
     public final void rule__CPBranchTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18618:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) )
-            // InternalRoom.g:18619:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18847:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:18848:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:18619:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
-            // InternalRoom.g:18620:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            // InternalRoom.g:18848:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18849:1: ( rule__CPBranchTransition__NameAssignment_1 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); 
-            // InternalRoom.g:18621:1: ( rule__CPBranchTransition__NameAssignment_1 )?
-            int alt182=2;
-            int LA182_0 = input.LA(1);
+            // InternalRoom.g:18850:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            int alt185=2;
+            int LA185_0 = input.LA(1);
 
-            if ( (LA182_0==RULE_ID) ) {
-                alt182=1;
+            if ( (LA185_0==RULE_ID) ) {
+                alt185=1;
             }
-            switch (alt182) {
+            switch (alt185) {
                 case 1 :
-                    // InternalRoom.g:18621:2: rule__CPBranchTransition__NameAssignment_1
+                    // InternalRoom.g:18850:2: rule__CPBranchTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__NameAssignment_1();
@@ -51270,16 +51929,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__2"
-    // InternalRoom.g:18631:1: rule__CPBranchTransition__Group__2 : rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ;
+    // InternalRoom.g:18860:1: rule__CPBranchTransition__Group__2 : rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ;
     public final void rule__CPBranchTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18635:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 )
-            // InternalRoom.g:18636:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3
+            // InternalRoom.g:18864:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 )
+            // InternalRoom.g:18865:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__CPBranchTransition__Group__2__Impl();
 
             state._fsp--;
@@ -51308,17 +51967,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__2__Impl"
-    // InternalRoom.g:18643:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:18872:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ;
     public final void rule__CPBranchTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18647:1: ( ( ':' ) )
-            // InternalRoom.g:18648:1: ( ':' )
+            // InternalRoom.g:18876:1: ( ( ':' ) )
+            // InternalRoom.g:18877:1: ( ':' )
             {
-            // InternalRoom.g:18648:1: ( ':' )
-            // InternalRoom.g:18649:1: ':'
+            // InternalRoom.g:18877:1: ( ':' )
+            // InternalRoom.g:18878:1: ':'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -51345,14 +52004,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__3"
-    // InternalRoom.g:18662:1: rule__CPBranchTransition__Group__3 : rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ;
+    // InternalRoom.g:18891:1: rule__CPBranchTransition__Group__3 : rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ;
     public final void rule__CPBranchTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18666:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 )
-            // InternalRoom.g:18667:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4
+            // InternalRoom.g:18895:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 )
+            // InternalRoom.g:18896:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__CPBranchTransition__Group__3__Impl();
@@ -51383,21 +52042,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__3__Impl"
-    // InternalRoom.g:18674:1: rule__CPBranchTransition__Group__3__Impl : ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ;
+    // InternalRoom.g:18903:1: rule__CPBranchTransition__Group__3__Impl : ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ;
     public final void rule__CPBranchTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18678:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) )
-            // InternalRoom.g:18679:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18907:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:18908:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:18679:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
-            // InternalRoom.g:18680:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalRoom.g:18908:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18909:1: ( rule__CPBranchTransition__FromAssignment_3 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); 
-            // InternalRoom.g:18681:1: ( rule__CPBranchTransition__FromAssignment_3 )
-            // InternalRoom.g:18681:2: rule__CPBranchTransition__FromAssignment_3
+            // InternalRoom.g:18910:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalRoom.g:18910:2: rule__CPBranchTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__FromAssignment_3();
@@ -51430,16 +52089,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__4"
-    // InternalRoom.g:18691:1: rule__CPBranchTransition__Group__4 : rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ;
+    // InternalRoom.g:18920:1: rule__CPBranchTransition__Group__4 : rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ;
     public final void rule__CPBranchTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18695:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 )
-            // InternalRoom.g:18696:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5
+            // InternalRoom.g:18924:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 )
+            // InternalRoom.g:18925:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5
             {
-            pushFollow(FOLLOW_88);
+            pushFollow(FOLLOW_89);
             rule__CPBranchTransition__Group__4__Impl();
 
             state._fsp--;
@@ -51468,17 +52127,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__4__Impl"
-    // InternalRoom.g:18703:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:18932:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ;
     public final void rule__CPBranchTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18707:1: ( ( '->' ) )
-            // InternalRoom.g:18708:1: ( '->' )
+            // InternalRoom.g:18936:1: ( ( '->' ) )
+            // InternalRoom.g:18937:1: ( '->' )
             {
-            // InternalRoom.g:18708:1: ( '->' )
-            // InternalRoom.g:18709:1: '->'
+            // InternalRoom.g:18937:1: ( '->' )
+            // InternalRoom.g:18938:1: '->'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -51505,14 +52164,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__5"
-    // InternalRoom.g:18722:1: rule__CPBranchTransition__Group__5 : rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ;
+    // InternalRoom.g:18951:1: rule__CPBranchTransition__Group__5 : rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ;
     public final void rule__CPBranchTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18726:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 )
-            // InternalRoom.g:18727:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6
+            // InternalRoom.g:18955:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 )
+            // InternalRoom.g:18956:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__CPBranchTransition__Group__5__Impl();
@@ -51543,21 +52202,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__5__Impl"
-    // InternalRoom.g:18734:1: rule__CPBranchTransition__Group__5__Impl : ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ;
+    // InternalRoom.g:18963:1: rule__CPBranchTransition__Group__5__Impl : ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ;
     public final void rule__CPBranchTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18738:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) )
-            // InternalRoom.g:18739:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18967:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:18968:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:18739:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
-            // InternalRoom.g:18740:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalRoom.g:18968:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18969:1: ( rule__CPBranchTransition__ToAssignment_5 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); 
-            // InternalRoom.g:18741:1: ( rule__CPBranchTransition__ToAssignment_5 )
-            // InternalRoom.g:18741:2: rule__CPBranchTransition__ToAssignment_5
+            // InternalRoom.g:18970:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalRoom.g:18970:2: rule__CPBranchTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ToAssignment_5();
@@ -51590,14 +52249,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__6"
-    // InternalRoom.g:18751:1: rule__CPBranchTransition__Group__6 : rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ;
+    // InternalRoom.g:18980:1: rule__CPBranchTransition__Group__6 : rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ;
     public final void rule__CPBranchTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18755:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 )
-            // InternalRoom.g:18756:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7
+            // InternalRoom.g:18984:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 )
+            // InternalRoom.g:18985:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__CPBranchTransition__Group__6__Impl();
@@ -51628,29 +52287,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__6__Impl"
-    // InternalRoom.g:18763:1: rule__CPBranchTransition__Group__6__Impl : ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ;
+    // InternalRoom.g:18992:1: rule__CPBranchTransition__Group__6__Impl : ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ;
     public final void rule__CPBranchTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18767:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) )
-            // InternalRoom.g:18768:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18996:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:18997:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:18768:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:18769:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            // InternalRoom.g:18997:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18998:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); 
-            // InternalRoom.g:18770:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
-            int alt183=2;
-            int LA183_0 = input.LA(1);
+            // InternalRoom.g:18999:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            int alt186=2;
+            int LA186_0 = input.LA(1);
 
-            if ( (LA183_0==62) ) {
-                alt183=1;
+            if ( (LA186_0==62) ) {
+                alt186=1;
             }
-            switch (alt183) {
+            switch (alt186) {
                 case 1 :
-                    // InternalRoom.g:18770:2: rule__CPBranchTransition__DocuAssignment_6
+                    // InternalRoom.g:18999:2: rule__CPBranchTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__DocuAssignment_6();
@@ -51686,16 +52345,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__7"
-    // InternalRoom.g:18780:1: rule__CPBranchTransition__Group__7 : rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ;
+    // InternalRoom.g:19009:1: rule__CPBranchTransition__Group__7 : rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ;
     public final void rule__CPBranchTransition__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18784:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 )
-            // InternalRoom.g:18785:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8
+            // InternalRoom.g:19013:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 )
+            // InternalRoom.g:19014:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8
             {
-            pushFollow(FOLLOW_95);
+            pushFollow(FOLLOW_96);
             rule__CPBranchTransition__Group__7__Impl();
 
             state._fsp--;
@@ -51724,17 +52383,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__7__Impl"
-    // InternalRoom.g:18792:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:19021:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ;
     public final void rule__CPBranchTransition__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18796:1: ( ( '{' ) )
-            // InternalRoom.g:18797:1: ( '{' )
+            // InternalRoom.g:19025:1: ( ( '{' ) )
+            // InternalRoom.g:19026:1: ( '{' )
             {
-            // InternalRoom.g:18797:1: ( '{' )
-            // InternalRoom.g:18798:1: '{'
+            // InternalRoom.g:19026:1: ( '{' )
+            // InternalRoom.g:19027:1: '{'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -51761,14 +52420,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__8"
-    // InternalRoom.g:18811:1: rule__CPBranchTransition__Group__8 : rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ;
+    // InternalRoom.g:19040:1: rule__CPBranchTransition__Group__8 : rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ;
     public final void rule__CPBranchTransition__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18815:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 )
-            // InternalRoom.g:18816:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9
+            // InternalRoom.g:19044:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 )
+            // InternalRoom.g:19045:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9
             {
             pushFollow(FOLLOW_27);
             rule__CPBranchTransition__Group__8__Impl();
@@ -51799,17 +52458,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__8__Impl"
-    // InternalRoom.g:18823:1: rule__CPBranchTransition__Group__8__Impl : ( 'cond' ) ;
+    // InternalRoom.g:19052:1: rule__CPBranchTransition__Group__8__Impl : ( 'cond' ) ;
     public final void rule__CPBranchTransition__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18827:1: ( ( 'cond' ) )
-            // InternalRoom.g:18828:1: ( 'cond' )
+            // InternalRoom.g:19056:1: ( ( 'cond' ) )
+            // InternalRoom.g:19057:1: ( 'cond' )
             {
-            // InternalRoom.g:18828:1: ( 'cond' )
-            // InternalRoom.g:18829:1: 'cond'
+            // InternalRoom.g:19057:1: ( 'cond' )
+            // InternalRoom.g:19058:1: 'cond'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); 
             match(input,111,FOLLOW_2); 
@@ -51836,16 +52495,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__9"
-    // InternalRoom.g:18842:1: rule__CPBranchTransition__Group__9 : rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ;
+    // InternalRoom.g:19071:1: rule__CPBranchTransition__Group__9 : rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ;
     public final void rule__CPBranchTransition__Group__9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18846:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 )
-            // InternalRoom.g:18847:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10
+            // InternalRoom.g:19075:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 )
+            // InternalRoom.g:19076:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__CPBranchTransition__Group__9__Impl();
 
             state._fsp--;
@@ -51874,21 +52533,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__9__Impl"
-    // InternalRoom.g:18854:1: rule__CPBranchTransition__Group__9__Impl : ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ;
+    // InternalRoom.g:19083:1: rule__CPBranchTransition__Group__9__Impl : ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ;
     public final void rule__CPBranchTransition__Group__9__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18858:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) )
-            // InternalRoom.g:18859:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
+            // InternalRoom.g:19087:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) )
+            // InternalRoom.g:19088:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
             {
-            // InternalRoom.g:18859:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
-            // InternalRoom.g:18860:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalRoom.g:19088:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
+            // InternalRoom.g:19089:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); 
-            // InternalRoom.g:18861:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
-            // InternalRoom.g:18861:2: rule__CPBranchTransition__ConditionAssignment_9
+            // InternalRoom.g:19090:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalRoom.g:19090:2: rule__CPBranchTransition__ConditionAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ConditionAssignment_9();
@@ -51921,16 +52580,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__10"
-    // InternalRoom.g:18871:1: rule__CPBranchTransition__Group__10 : rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ;
+    // InternalRoom.g:19100:1: rule__CPBranchTransition__Group__10 : rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ;
     public final void rule__CPBranchTransition__Group__10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18875:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 )
-            // InternalRoom.g:18876:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11
+            // InternalRoom.g:19104:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 )
+            // InternalRoom.g:19105:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11
             {
-            pushFollow(FOLLOW_89);
+            pushFollow(FOLLOW_90);
             rule__CPBranchTransition__Group__10__Impl();
 
             state._fsp--;
@@ -51959,29 +52618,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__10__Impl"
-    // InternalRoom.g:18883:1: rule__CPBranchTransition__Group__10__Impl : ( ( rule__CPBranchTransition__Group_10__0 )? ) ;
+    // InternalRoom.g:19112:1: rule__CPBranchTransition__Group__10__Impl : ( ( rule__CPBranchTransition__Group_10__0 )? ) ;
     public final void rule__CPBranchTransition__Group__10__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18887:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) )
-            // InternalRoom.g:18888:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
+            // InternalRoom.g:19116:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) )
+            // InternalRoom.g:19117:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
             {
-            // InternalRoom.g:18888:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
-            // InternalRoom.g:18889:1: ( rule__CPBranchTransition__Group_10__0 )?
+            // InternalRoom.g:19117:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
+            // InternalRoom.g:19118:1: ( rule__CPBranchTransition__Group_10__0 )?
             {
              before(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); 
-            // InternalRoom.g:18890:1: ( rule__CPBranchTransition__Group_10__0 )?
-            int alt184=2;
-            int LA184_0 = input.LA(1);
+            // InternalRoom.g:19119:1: ( rule__CPBranchTransition__Group_10__0 )?
+            int alt187=2;
+            int LA187_0 = input.LA(1);
 
-            if ( (LA184_0==107) ) {
-                alt184=1;
+            if ( (LA187_0==107) ) {
+                alt187=1;
             }
-            switch (alt184) {
+            switch (alt187) {
                 case 1 :
-                    // InternalRoom.g:18890:2: rule__CPBranchTransition__Group_10__0
+                    // InternalRoom.g:19119:2: rule__CPBranchTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__Group_10__0();
@@ -52017,14 +52676,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__11"
-    // InternalRoom.g:18900:1: rule__CPBranchTransition__Group__11 : rule__CPBranchTransition__Group__11__Impl ;
+    // InternalRoom.g:19129:1: rule__CPBranchTransition__Group__11 : rule__CPBranchTransition__Group__11__Impl ;
     public final void rule__CPBranchTransition__Group__11() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18904:1: ( rule__CPBranchTransition__Group__11__Impl )
-            // InternalRoom.g:18905:2: rule__CPBranchTransition__Group__11__Impl
+            // InternalRoom.g:19133:1: ( rule__CPBranchTransition__Group__11__Impl )
+            // InternalRoom.g:19134:2: rule__CPBranchTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__11__Impl();
@@ -52050,17 +52709,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__11__Impl"
-    // InternalRoom.g:18911:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ;
+    // InternalRoom.g:19140:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ;
     public final void rule__CPBranchTransition__Group__11__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18915:1: ( ( '}' ) )
-            // InternalRoom.g:18916:1: ( '}' )
+            // InternalRoom.g:19144:1: ( ( '}' ) )
+            // InternalRoom.g:19145:1: ( '}' )
             {
-            // InternalRoom.g:18916:1: ( '}' )
-            // InternalRoom.g:18917:1: '}'
+            // InternalRoom.g:19145:1: ( '}' )
+            // InternalRoom.g:19146:1: '}'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,45,FOLLOW_2); 
@@ -52087,14 +52746,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__0"
-    // InternalRoom.g:18954:1: rule__CPBranchTransition__Group_10__0 : rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ;
+    // InternalRoom.g:19183:1: rule__CPBranchTransition__Group_10__0 : rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ;
     public final void rule__CPBranchTransition__Group_10__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18958:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 )
-            // InternalRoom.g:18959:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1
+            // InternalRoom.g:19187:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 )
+            // InternalRoom.g:19188:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1
             {
             pushFollow(FOLLOW_27);
             rule__CPBranchTransition__Group_10__0__Impl();
@@ -52125,17 +52784,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__0__Impl"
-    // InternalRoom.g:18966:1: rule__CPBranchTransition__Group_10__0__Impl : ( 'action' ) ;
+    // InternalRoom.g:19195:1: rule__CPBranchTransition__Group_10__0__Impl : ( 'action' ) ;
     public final void rule__CPBranchTransition__Group_10__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18970:1: ( ( 'action' ) )
-            // InternalRoom.g:18971:1: ( 'action' )
+            // InternalRoom.g:19199:1: ( ( 'action' ) )
+            // InternalRoom.g:19200:1: ( 'action' )
             {
-            // InternalRoom.g:18971:1: ( 'action' )
-            // InternalRoom.g:18972:1: 'action'
+            // InternalRoom.g:19200:1: ( 'action' )
+            // InternalRoom.g:19201:1: 'action'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); 
             match(input,107,FOLLOW_2); 
@@ -52162,14 +52821,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__1"
-    // InternalRoom.g:18985:1: rule__CPBranchTransition__Group_10__1 : rule__CPBranchTransition__Group_10__1__Impl ;
+    // InternalRoom.g:19214:1: rule__CPBranchTransition__Group_10__1 : rule__CPBranchTransition__Group_10__1__Impl ;
     public final void rule__CPBranchTransition__Group_10__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:18989:1: ( rule__CPBranchTransition__Group_10__1__Impl )
-            // InternalRoom.g:18990:2: rule__CPBranchTransition__Group_10__1__Impl
+            // InternalRoom.g:19218:1: ( rule__CPBranchTransition__Group_10__1__Impl )
+            // InternalRoom.g:19219:2: rule__CPBranchTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group_10__1__Impl();
@@ -52195,21 +52854,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group_10__1__Impl"
-    // InternalRoom.g:18996:1: rule__CPBranchTransition__Group_10__1__Impl : ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ;
+    // InternalRoom.g:19225:1: rule__CPBranchTransition__Group_10__1__Impl : ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ;
     public final void rule__CPBranchTransition__Group_10__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19000:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) )
-            // InternalRoom.g:19001:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:19229:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) )
+            // InternalRoom.g:19230:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
             {
-            // InternalRoom.g:19001:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
-            // InternalRoom.g:19002:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:19230:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:19231:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); 
-            // InternalRoom.g:19003:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
-            // InternalRoom.g:19003:2: rule__CPBranchTransition__ActionAssignment_10_1
+            // InternalRoom.g:19232:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:19232:2: rule__CPBranchTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ActionAssignment_10_1();
@@ -52242,14 +52901,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__0"
-    // InternalRoom.g:19017:1: rule__RefinedTransition__Group__0 : rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ;
+    // InternalRoom.g:19246:1: rule__RefinedTransition__Group__0 : rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ;
     public final void rule__RefinedTransition__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19021:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 )
-            // InternalRoom.g:19022:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1
+            // InternalRoom.g:19250:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 )
+            // InternalRoom.g:19251:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefinedTransition__Group__0__Impl();
@@ -52280,17 +52939,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__0__Impl"
-    // InternalRoom.g:19029:1: rule__RefinedTransition__Group__0__Impl : ( 'RefinedTransition' ) ;
+    // InternalRoom.g:19258:1: rule__RefinedTransition__Group__0__Impl : ( 'RefinedTransition' ) ;
     public final void rule__RefinedTransition__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19033:1: ( ( 'RefinedTransition' ) )
-            // InternalRoom.g:19034:1: ( 'RefinedTransition' )
+            // InternalRoom.g:19262:1: ( ( 'RefinedTransition' ) )
+            // InternalRoom.g:19263:1: ( 'RefinedTransition' )
             {
-            // InternalRoom.g:19034:1: ( 'RefinedTransition' )
-            // InternalRoom.g:19035:1: 'RefinedTransition'
+            // InternalRoom.g:19263:1: ( 'RefinedTransition' )
+            // InternalRoom.g:19264:1: 'RefinedTransition'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); 
             match(input,112,FOLLOW_2); 
@@ -52317,14 +52976,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__1"
-    // InternalRoom.g:19048:1: rule__RefinedTransition__Group__1 : rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ;
+    // InternalRoom.g:19277:1: rule__RefinedTransition__Group__1 : rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ;
     public final void rule__RefinedTransition__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19052:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 )
-            // InternalRoom.g:19053:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2
+            // InternalRoom.g:19281:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 )
+            // InternalRoom.g:19282:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RefinedTransition__Group__1__Impl();
@@ -52355,21 +53014,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__1__Impl"
-    // InternalRoom.g:19060:1: rule__RefinedTransition__Group__1__Impl : ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ;
+    // InternalRoom.g:19289:1: rule__RefinedTransition__Group__1__Impl : ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ;
     public final void rule__RefinedTransition__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19064:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) )
-            // InternalRoom.g:19065:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
+            // InternalRoom.g:19293:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) )
+            // InternalRoom.g:19294:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
             {
-            // InternalRoom.g:19065:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
-            // InternalRoom.g:19066:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalRoom.g:19294:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
+            // InternalRoom.g:19295:1: ( rule__RefinedTransition__TargetAssignment_1 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); 
-            // InternalRoom.g:19067:1: ( rule__RefinedTransition__TargetAssignment_1 )
-            // InternalRoom.g:19067:2: rule__RefinedTransition__TargetAssignment_1
+            // InternalRoom.g:19296:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalRoom.g:19296:2: rule__RefinedTransition__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__TargetAssignment_1();
@@ -52402,14 +53061,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__2"
-    // InternalRoom.g:19077:1: rule__RefinedTransition__Group__2 : rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ;
+    // InternalRoom.g:19306:1: rule__RefinedTransition__Group__2 : rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ;
     public final void rule__RefinedTransition__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19081:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 )
-            // InternalRoom.g:19082:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3
+            // InternalRoom.g:19310:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 )
+            // InternalRoom.g:19311:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RefinedTransition__Group__2__Impl();
@@ -52440,29 +53099,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__2__Impl"
-    // InternalRoom.g:19089:1: rule__RefinedTransition__Group__2__Impl : ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:19318:1: rule__RefinedTransition__Group__2__Impl : ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ;
     public final void rule__RefinedTransition__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19093:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) )
-            // InternalRoom.g:19094:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
+            // InternalRoom.g:19322:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) )
+            // InternalRoom.g:19323:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:19094:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
-            // InternalRoom.g:19095:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            // InternalRoom.g:19323:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
+            // InternalRoom.g:19324:1: ( rule__RefinedTransition__DocuAssignment_2 )?
             {
              before(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:19096:1: ( rule__RefinedTransition__DocuAssignment_2 )?
-            int alt185=2;
-            int LA185_0 = input.LA(1);
+            // InternalRoom.g:19325:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            int alt188=2;
+            int LA188_0 = input.LA(1);
 
-            if ( (LA185_0==62) ) {
-                alt185=1;
+            if ( (LA188_0==62) ) {
+                alt188=1;
             }
-            switch (alt185) {
+            switch (alt188) {
                 case 1 :
-                    // InternalRoom.g:19096:2: rule__RefinedTransition__DocuAssignment_2
+                    // InternalRoom.g:19325:2: rule__RefinedTransition__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedTransition__DocuAssignment_2();
@@ -52498,16 +53157,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__3"
-    // InternalRoom.g:19106:1: rule__RefinedTransition__Group__3 : rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ;
+    // InternalRoom.g:19335:1: rule__RefinedTransition__Group__3 : rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ;
     public final void rule__RefinedTransition__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19110:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 )
-            // InternalRoom.g:19111:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4
+            // InternalRoom.g:19339:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 )
+            // InternalRoom.g:19340:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4
             {
-            pushFollow(FOLLOW_96);
+            pushFollow(FOLLOW_97);
             rule__RefinedTransition__Group__3__Impl();
 
             state._fsp--;
@@ -52536,17 +53195,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__3__Impl"
-    // InternalRoom.g:19118:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:19347:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ;
     public final void rule__RefinedTransition__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19122:1: ( ( '{' ) )
-            // InternalRoom.g:19123:1: ( '{' )
+            // InternalRoom.g:19351:1: ( ( '{' ) )
+            // InternalRoom.g:19352:1: ( '{' )
             {
-            // InternalRoom.g:19123:1: ( '{' )
-            // InternalRoom.g:19124:1: '{'
+            // InternalRoom.g:19352:1: ( '{' )
+            // InternalRoom.g:19353:1: '{'
             {
              before(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -52573,14 +53232,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__4"
-    // InternalRoom.g:19137:1: rule__RefinedTransition__Group__4 : rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ;
+    // InternalRoom.g:19366:1: rule__RefinedTransition__Group__4 : rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ;
     public final void rule__RefinedTransition__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19141:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 )
-            // InternalRoom.g:19142:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5
+            // InternalRoom.g:19370:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 )
+            // InternalRoom.g:19371:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5
             {
             pushFollow(FOLLOW_27);
             rule__RefinedTransition__Group__4__Impl();
@@ -52611,17 +53270,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__4__Impl"
-    // InternalRoom.g:19149:1: rule__RefinedTransition__Group__4__Impl : ( 'action' ) ;
+    // InternalRoom.g:19378:1: rule__RefinedTransition__Group__4__Impl : ( 'action' ) ;
     public final void rule__RefinedTransition__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19153:1: ( ( 'action' ) )
-            // InternalRoom.g:19154:1: ( 'action' )
+            // InternalRoom.g:19382:1: ( ( 'action' ) )
+            // InternalRoom.g:19383:1: ( 'action' )
             {
-            // InternalRoom.g:19154:1: ( 'action' )
-            // InternalRoom.g:19155:1: 'action'
+            // InternalRoom.g:19383:1: ( 'action' )
+            // InternalRoom.g:19384:1: 'action'
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); 
             match(input,107,FOLLOW_2); 
@@ -52648,16 +53307,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__5"
-    // InternalRoom.g:19168:1: rule__RefinedTransition__Group__5 : rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ;
+    // InternalRoom.g:19397:1: rule__RefinedTransition__Group__5 : rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ;
     public final void rule__RefinedTransition__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19172:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 )
-            // InternalRoom.g:19173:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6
+            // InternalRoom.g:19401:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 )
+            // InternalRoom.g:19402:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6
             {
-            pushFollow(FOLLOW_97);
+            pushFollow(FOLLOW_98);
             rule__RefinedTransition__Group__5__Impl();
 
             state._fsp--;
@@ -52686,21 +53345,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__5__Impl"
-    // InternalRoom.g:19180:1: rule__RefinedTransition__Group__5__Impl : ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ;
+    // InternalRoom.g:19409:1: rule__RefinedTransition__Group__5__Impl : ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ;
     public final void rule__RefinedTransition__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19184:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) )
-            // InternalRoom.g:19185:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
+            // InternalRoom.g:19413:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) )
+            // InternalRoom.g:19414:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
             {
-            // InternalRoom.g:19185:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
-            // InternalRoom.g:19186:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalRoom.g:19414:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
+            // InternalRoom.g:19415:1: ( rule__RefinedTransition__ActionAssignment_5 )
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); 
-            // InternalRoom.g:19187:1: ( rule__RefinedTransition__ActionAssignment_5 )
-            // InternalRoom.g:19187:2: rule__RefinedTransition__ActionAssignment_5
+            // InternalRoom.g:19416:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalRoom.g:19416:2: rule__RefinedTransition__ActionAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__ActionAssignment_5();
@@ -52733,14 +53392,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__6"
-    // InternalRoom.g:19197:1: rule__RefinedTransition__Group__6 : rule__RefinedTransition__Group__6__Impl ;
+    // InternalRoom.g:19426:1: rule__RefinedTransition__Group__6 : rule__RefinedTransition__Group__6__Impl ;
     public final void rule__RefinedTransition__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19201:1: ( rule__RefinedTransition__Group__6__Impl )
-            // InternalRoom.g:19202:2: rule__RefinedTransition__Group__6__Impl
+            // InternalRoom.g:19430:1: ( rule__RefinedTransition__Group__6__Impl )
+            // InternalRoom.g:19431:2: rule__RefinedTransition__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__6__Impl();
@@ -52766,17 +53425,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__6__Impl"
-    // InternalRoom.g:19208:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:19437:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ;
     public final void rule__RefinedTransition__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19212:1: ( ( '}' ) )
-            // InternalRoom.g:19213:1: ( '}' )
+            // InternalRoom.g:19441:1: ( ( '}' ) )
+            // InternalRoom.g:19442:1: ( '}' )
             {
-            // InternalRoom.g:19213:1: ( '}' )
-            // InternalRoom.g:19214:1: '}'
+            // InternalRoom.g:19442:1: ( '}' )
+            // InternalRoom.g:19443:1: '}'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -52803,14 +53462,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__0"
-    // InternalRoom.g:19241:1: rule__TrPointTerminal__Group__0 : rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ;
+    // InternalRoom.g:19470:1: rule__TrPointTerminal__Group__0 : rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ;
     public final void rule__TrPointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19245:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 )
-            // InternalRoom.g:19246:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1
+            // InternalRoom.g:19474:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 )
+            // InternalRoom.g:19475:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__TrPointTerminal__Group__0__Impl();
@@ -52841,17 +53500,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__0__Impl"
-    // InternalRoom.g:19253:1: rule__TrPointTerminal__Group__0__Impl : ( 'my' ) ;
+    // InternalRoom.g:19482:1: rule__TrPointTerminal__Group__0__Impl : ( 'my' ) ;
     public final void rule__TrPointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19257:1: ( ( 'my' ) )
-            // InternalRoom.g:19258:1: ( 'my' )
+            // InternalRoom.g:19486:1: ( ( 'my' ) )
+            // InternalRoom.g:19487:1: ( 'my' )
             {
-            // InternalRoom.g:19258:1: ( 'my' )
-            // InternalRoom.g:19259:1: 'my'
+            // InternalRoom.g:19487:1: ( 'my' )
+            // InternalRoom.g:19488:1: 'my'
             {
              before(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); 
             match(input,113,FOLLOW_2); 
@@ -52878,14 +53537,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__1"
-    // InternalRoom.g:19272:1: rule__TrPointTerminal__Group__1 : rule__TrPointTerminal__Group__1__Impl ;
+    // InternalRoom.g:19501:1: rule__TrPointTerminal__Group__1 : rule__TrPointTerminal__Group__1__Impl ;
     public final void rule__TrPointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19276:1: ( rule__TrPointTerminal__Group__1__Impl )
-            // InternalRoom.g:19277:2: rule__TrPointTerminal__Group__1__Impl
+            // InternalRoom.g:19505:1: ( rule__TrPointTerminal__Group__1__Impl )
+            // InternalRoom.g:19506:2: rule__TrPointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__1__Impl();
@@ -52911,21 +53570,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__Group__1__Impl"
-    // InternalRoom.g:19283:1: rule__TrPointTerminal__Group__1__Impl : ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ;
+    // InternalRoom.g:19512:1: rule__TrPointTerminal__Group__1__Impl : ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ;
     public final void rule__TrPointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19287:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) )
-            // InternalRoom.g:19288:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
+            // InternalRoom.g:19516:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) )
+            // InternalRoom.g:19517:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
             {
-            // InternalRoom.g:19288:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
-            // InternalRoom.g:19289:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalRoom.g:19517:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
+            // InternalRoom.g:19518:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); 
-            // InternalRoom.g:19290:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
-            // InternalRoom.g:19290:2: rule__TrPointTerminal__TrPointAssignment_1
+            // InternalRoom.g:19519:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalRoom.g:19519:2: rule__TrPointTerminal__TrPointAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__TrPointAssignment_1();
@@ -52958,16 +53617,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__0"
-    // InternalRoom.g:19304:1: rule__SubStateTrPointTerminal__Group__0 : rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ;
+    // InternalRoom.g:19533:1: rule__SubStateTrPointTerminal__Group__0 : rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ;
     public final void rule__SubStateTrPointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19308:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 )
-            // InternalRoom.g:19309:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1
+            // InternalRoom.g:19537:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 )
+            // InternalRoom.g:19538:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1
             {
-            pushFollow(FOLLOW_62);
+            pushFollow(FOLLOW_63);
             rule__SubStateTrPointTerminal__Group__0__Impl();
 
             state._fsp--;
@@ -52996,21 +53655,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__0__Impl"
-    // InternalRoom.g:19316:1: rule__SubStateTrPointTerminal__Group__0__Impl : ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ;
+    // InternalRoom.g:19545:1: rule__SubStateTrPointTerminal__Group__0__Impl : ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ;
     public final void rule__SubStateTrPointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19320:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) )
-            // InternalRoom.g:19321:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
+            // InternalRoom.g:19549:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) )
+            // InternalRoom.g:19550:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
             {
-            // InternalRoom.g:19321:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
-            // InternalRoom.g:19322:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalRoom.g:19550:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
+            // InternalRoom.g:19551:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); 
-            // InternalRoom.g:19323:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
-            // InternalRoom.g:19323:2: rule__SubStateTrPointTerminal__TrPointAssignment_0
+            // InternalRoom.g:19552:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalRoom.g:19552:2: rule__SubStateTrPointTerminal__TrPointAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__TrPointAssignment_0();
@@ -53043,14 +53702,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__1"
-    // InternalRoom.g:19333:1: rule__SubStateTrPointTerminal__Group__1 : rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ;
+    // InternalRoom.g:19562:1: rule__SubStateTrPointTerminal__Group__1 : rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ;
     public final void rule__SubStateTrPointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19337:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 )
-            // InternalRoom.g:19338:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2
+            // InternalRoom.g:19566:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 )
+            // InternalRoom.g:19567:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SubStateTrPointTerminal__Group__1__Impl();
@@ -53081,17 +53740,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__1__Impl"
-    // InternalRoom.g:19345:1: rule__SubStateTrPointTerminal__Group__1__Impl : ( 'of' ) ;
+    // InternalRoom.g:19574:1: rule__SubStateTrPointTerminal__Group__1__Impl : ( 'of' ) ;
     public final void rule__SubStateTrPointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19349:1: ( ( 'of' ) )
-            // InternalRoom.g:19350:1: ( 'of' )
+            // InternalRoom.g:19578:1: ( ( 'of' ) )
+            // InternalRoom.g:19579:1: ( 'of' )
             {
-            // InternalRoom.g:19350:1: ( 'of' )
-            // InternalRoom.g:19351:1: 'of'
+            // InternalRoom.g:19579:1: ( 'of' )
+            // InternalRoom.g:19580:1: 'of'
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); 
             match(input,53,FOLLOW_2); 
@@ -53118,14 +53777,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__2"
-    // InternalRoom.g:19364:1: rule__SubStateTrPointTerminal__Group__2 : rule__SubStateTrPointTerminal__Group__2__Impl ;
+    // InternalRoom.g:19593:1: rule__SubStateTrPointTerminal__Group__2 : rule__SubStateTrPointTerminal__Group__2__Impl ;
     public final void rule__SubStateTrPointTerminal__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19368:1: ( rule__SubStateTrPointTerminal__Group__2__Impl )
-            // InternalRoom.g:19369:2: rule__SubStateTrPointTerminal__Group__2__Impl
+            // InternalRoom.g:19597:1: ( rule__SubStateTrPointTerminal__Group__2__Impl )
+            // InternalRoom.g:19598:2: rule__SubStateTrPointTerminal__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__2__Impl();
@@ -53151,21 +53810,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__Group__2__Impl"
-    // InternalRoom.g:19375:1: rule__SubStateTrPointTerminal__Group__2__Impl : ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ;
+    // InternalRoom.g:19604:1: rule__SubStateTrPointTerminal__Group__2__Impl : ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ;
     public final void rule__SubStateTrPointTerminal__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19379:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) )
-            // InternalRoom.g:19380:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
+            // InternalRoom.g:19608:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) )
+            // InternalRoom.g:19609:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
             {
-            // InternalRoom.g:19380:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
-            // InternalRoom.g:19381:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalRoom.g:19609:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
+            // InternalRoom.g:19610:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); 
-            // InternalRoom.g:19382:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
-            // InternalRoom.g:19382:2: rule__SubStateTrPointTerminal__StateAssignment_2
+            // InternalRoom.g:19611:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalRoom.g:19611:2: rule__SubStateTrPointTerminal__StateAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__StateAssignment_2();
@@ -53198,14 +53857,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__0"
-    // InternalRoom.g:19398:1: rule__ChoicepointTerminal__Group__0 : rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ;
+    // InternalRoom.g:19627:1: rule__ChoicepointTerminal__Group__0 : rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ;
     public final void rule__ChoicepointTerminal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19402:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 )
-            // InternalRoom.g:19403:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1
+            // InternalRoom.g:19631:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 )
+            // InternalRoom.g:19632:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ChoicepointTerminal__Group__0__Impl();
@@ -53236,17 +53895,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__0__Impl"
-    // InternalRoom.g:19410:1: rule__ChoicepointTerminal__Group__0__Impl : ( 'cp' ) ;
+    // InternalRoom.g:19639:1: rule__ChoicepointTerminal__Group__0__Impl : ( 'cp' ) ;
     public final void rule__ChoicepointTerminal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19414:1: ( ( 'cp' ) )
-            // InternalRoom.g:19415:1: ( 'cp' )
+            // InternalRoom.g:19643:1: ( ( 'cp' ) )
+            // InternalRoom.g:19644:1: ( 'cp' )
             {
-            // InternalRoom.g:19415:1: ( 'cp' )
-            // InternalRoom.g:19416:1: 'cp'
+            // InternalRoom.g:19644:1: ( 'cp' )
+            // InternalRoom.g:19645:1: 'cp'
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); 
             match(input,114,FOLLOW_2); 
@@ -53273,14 +53932,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__1"
-    // InternalRoom.g:19429:1: rule__ChoicepointTerminal__Group__1 : rule__ChoicepointTerminal__Group__1__Impl ;
+    // InternalRoom.g:19658:1: rule__ChoicepointTerminal__Group__1 : rule__ChoicepointTerminal__Group__1__Impl ;
     public final void rule__ChoicepointTerminal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19433:1: ( rule__ChoicepointTerminal__Group__1__Impl )
-            // InternalRoom.g:19434:2: rule__ChoicepointTerminal__Group__1__Impl
+            // InternalRoom.g:19662:1: ( rule__ChoicepointTerminal__Group__1__Impl )
+            // InternalRoom.g:19663:2: rule__ChoicepointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__1__Impl();
@@ -53306,21 +53965,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__Group__1__Impl"
-    // InternalRoom.g:19440:1: rule__ChoicepointTerminal__Group__1__Impl : ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ;
+    // InternalRoom.g:19669:1: rule__ChoicepointTerminal__Group__1__Impl : ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ;
     public final void rule__ChoicepointTerminal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19444:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) )
-            // InternalRoom.g:19445:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
+            // InternalRoom.g:19673:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) )
+            // InternalRoom.g:19674:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
             {
-            // InternalRoom.g:19445:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
-            // InternalRoom.g:19446:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalRoom.g:19674:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
+            // InternalRoom.g:19675:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); 
-            // InternalRoom.g:19447:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
-            // InternalRoom.g:19447:2: rule__ChoicepointTerminal__CpAssignment_1
+            // InternalRoom.g:19676:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalRoom.g:19676:2: rule__ChoicepointTerminal__CpAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__CpAssignment_1();
@@ -53353,14 +54012,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__0"
-    // InternalRoom.g:19461:1: rule__Trigger__Group__0 : rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ;
+    // InternalRoom.g:19690:1: rule__Trigger__Group__0 : rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ;
     public final void rule__Trigger__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19465:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 )
-            // InternalRoom.g:19466:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1
+            // InternalRoom.g:19694:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 )
+            // InternalRoom.g:19695:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Trigger__Group__0__Impl();
@@ -53391,17 +54050,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__0__Impl"
-    // InternalRoom.g:19473:1: rule__Trigger__Group__0__Impl : ( '<' ) ;
+    // InternalRoom.g:19702:1: rule__Trigger__Group__0__Impl : ( '<' ) ;
     public final void rule__Trigger__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19477:1: ( ( '<' ) )
-            // InternalRoom.g:19478:1: ( '<' )
+            // InternalRoom.g:19706:1: ( ( '<' ) )
+            // InternalRoom.g:19707:1: ( '<' )
             {
-            // InternalRoom.g:19478:1: ( '<' )
-            // InternalRoom.g:19479:1: '<'
+            // InternalRoom.g:19707:1: ( '<' )
+            // InternalRoom.g:19708:1: '<'
             {
              before(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); 
             match(input,115,FOLLOW_2); 
@@ -53428,16 +54087,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__1"
-    // InternalRoom.g:19492:1: rule__Trigger__Group__1 : rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ;
+    // InternalRoom.g:19721:1: rule__Trigger__Group__1 : rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ;
     public final void rule__Trigger__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19496:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 )
-            // InternalRoom.g:19497:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2
+            // InternalRoom.g:19725:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 )
+            // InternalRoom.g:19726:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2
             {
-            pushFollow(FOLLOW_98);
+            pushFollow(FOLLOW_99);
             rule__Trigger__Group__1__Impl();
 
             state._fsp--;
@@ -53466,21 +54125,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__1__Impl"
-    // InternalRoom.g:19504:1: rule__Trigger__Group__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ;
+    // InternalRoom.g:19733:1: rule__Trigger__Group__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ;
     public final void rule__Trigger__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19508:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) )
-            // InternalRoom.g:19509:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
+            // InternalRoom.g:19737:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) )
+            // InternalRoom.g:19738:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
             {
-            // InternalRoom.g:19509:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
-            // InternalRoom.g:19510:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalRoom.g:19738:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
+            // InternalRoom.g:19739:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); 
-            // InternalRoom.g:19511:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
-            // InternalRoom.g:19511:2: rule__Trigger__MsgFromIfPairsAssignment_1
+            // InternalRoom.g:19740:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalRoom.g:19740:2: rule__Trigger__MsgFromIfPairsAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_1();
@@ -53513,16 +54172,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__2"
-    // InternalRoom.g:19521:1: rule__Trigger__Group__2 : rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ;
+    // InternalRoom.g:19750:1: rule__Trigger__Group__2 : rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ;
     public final void rule__Trigger__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19525:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 )
-            // InternalRoom.g:19526:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3
+            // InternalRoom.g:19754:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 )
+            // InternalRoom.g:19755:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3
             {
-            pushFollow(FOLLOW_98);
+            pushFollow(FOLLOW_99);
             rule__Trigger__Group__2__Impl();
 
             state._fsp--;
@@ -53551,35 +54210,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__2__Impl"
-    // InternalRoom.g:19533:1: rule__Trigger__Group__2__Impl : ( ( rule__Trigger__Group_2__0 )* ) ;
+    // InternalRoom.g:19762:1: rule__Trigger__Group__2__Impl : ( ( rule__Trigger__Group_2__0 )* ) ;
     public final void rule__Trigger__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19537:1: ( ( ( rule__Trigger__Group_2__0 )* ) )
-            // InternalRoom.g:19538:1: ( ( rule__Trigger__Group_2__0 )* )
+            // InternalRoom.g:19766:1: ( ( ( rule__Trigger__Group_2__0 )* ) )
+            // InternalRoom.g:19767:1: ( ( rule__Trigger__Group_2__0 )* )
             {
-            // InternalRoom.g:19538:1: ( ( rule__Trigger__Group_2__0 )* )
-            // InternalRoom.g:19539:1: ( rule__Trigger__Group_2__0 )*
+            // InternalRoom.g:19767:1: ( ( rule__Trigger__Group_2__0 )* )
+            // InternalRoom.g:19768:1: ( rule__Trigger__Group_2__0 )*
             {
              before(grammarAccess.getTriggerAccess().getGroup_2()); 
-            // InternalRoom.g:19540:1: ( rule__Trigger__Group_2__0 )*
-            loop186:
+            // InternalRoom.g:19769:1: ( rule__Trigger__Group_2__0 )*
+            loop189:
             do {
-                int alt186=2;
-                int LA186_0 = input.LA(1);
+                int alt189=2;
+                int LA189_0 = input.LA(1);
 
-                if ( (LA186_0==117) ) {
-                    alt186=1;
+                if ( (LA189_0==117) ) {
+                    alt189=1;
                 }
 
 
-                switch (alt186) {
+                switch (alt189) {
             	case 1 :
-            	    // InternalRoom.g:19540:2: rule__Trigger__Group_2__0
+            	    // InternalRoom.g:19769:2: rule__Trigger__Group_2__0
             	    {
-            	    pushFollow(FOLLOW_99);
+            	    pushFollow(FOLLOW_100);
             	    rule__Trigger__Group_2__0();
 
             	    state._fsp--;
@@ -53589,7 +54248,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop186;
+            	    break loop189;
                 }
             } while (true);
 
@@ -53616,16 +54275,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__3"
-    // InternalRoom.g:19550:1: rule__Trigger__Group__3 : rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ;
+    // InternalRoom.g:19779:1: rule__Trigger__Group__3 : rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ;
     public final void rule__Trigger__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19554:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 )
-            // InternalRoom.g:19555:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4
+            // InternalRoom.g:19783:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 )
+            // InternalRoom.g:19784:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4
             {
-            pushFollow(FOLLOW_98);
+            pushFollow(FOLLOW_99);
             rule__Trigger__Group__3__Impl();
 
             state._fsp--;
@@ -53654,29 +54313,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__3__Impl"
-    // InternalRoom.g:19562:1: rule__Trigger__Group__3__Impl : ( ( rule__Trigger__GuardAssignment_3 )? ) ;
+    // InternalRoom.g:19791:1: rule__Trigger__Group__3__Impl : ( ( rule__Trigger__GuardAssignment_3 )? ) ;
     public final void rule__Trigger__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19566:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) )
-            // InternalRoom.g:19567:1: ( ( rule__Trigger__GuardAssignment_3 )? )
+            // InternalRoom.g:19795:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) )
+            // InternalRoom.g:19796:1: ( ( rule__Trigger__GuardAssignment_3 )? )
             {
-            // InternalRoom.g:19567:1: ( ( rule__Trigger__GuardAssignment_3 )? )
-            // InternalRoom.g:19568:1: ( rule__Trigger__GuardAssignment_3 )?
+            // InternalRoom.g:19796:1: ( ( rule__Trigger__GuardAssignment_3 )? )
+            // InternalRoom.g:19797:1: ( rule__Trigger__GuardAssignment_3 )?
             {
              before(grammarAccess.getTriggerAccess().getGuardAssignment_3()); 
-            // InternalRoom.g:19569:1: ( rule__Trigger__GuardAssignment_3 )?
-            int alt187=2;
-            int LA187_0 = input.LA(1);
+            // InternalRoom.g:19798:1: ( rule__Trigger__GuardAssignment_3 )?
+            int alt190=2;
+            int LA190_0 = input.LA(1);
 
-            if ( (LA187_0==110) ) {
-                alt187=1;
+            if ( (LA190_0==110) ) {
+                alt190=1;
             }
-            switch (alt187) {
+            switch (alt190) {
                 case 1 :
-                    // InternalRoom.g:19569:2: rule__Trigger__GuardAssignment_3
+                    // InternalRoom.g:19798:2: rule__Trigger__GuardAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__Trigger__GuardAssignment_3();
@@ -53712,14 +54371,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__4"
-    // InternalRoom.g:19579:1: rule__Trigger__Group__4 : rule__Trigger__Group__4__Impl ;
+    // InternalRoom.g:19808:1: rule__Trigger__Group__4 : rule__Trigger__Group__4__Impl ;
     public final void rule__Trigger__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19583:1: ( rule__Trigger__Group__4__Impl )
-            // InternalRoom.g:19584:2: rule__Trigger__Group__4__Impl
+            // InternalRoom.g:19812:1: ( rule__Trigger__Group__4__Impl )
+            // InternalRoom.g:19813:2: rule__Trigger__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__4__Impl();
@@ -53745,17 +54404,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__4__Impl"
-    // InternalRoom.g:19590:1: rule__Trigger__Group__4__Impl : ( '>' ) ;
+    // InternalRoom.g:19819:1: rule__Trigger__Group__4__Impl : ( '>' ) ;
     public final void rule__Trigger__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19594:1: ( ( '>' ) )
-            // InternalRoom.g:19595:1: ( '>' )
+            // InternalRoom.g:19823:1: ( ( '>' ) )
+            // InternalRoom.g:19824:1: ( '>' )
             {
-            // InternalRoom.g:19595:1: ( '>' )
-            // InternalRoom.g:19596:1: '>'
+            // InternalRoom.g:19824:1: ( '>' )
+            // InternalRoom.g:19825:1: '>'
             {
              before(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); 
             match(input,116,FOLLOW_2); 
@@ -53782,14 +54441,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__0"
-    // InternalRoom.g:19619:1: rule__Trigger__Group_2__0 : rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ;
+    // InternalRoom.g:19848:1: rule__Trigger__Group_2__0 : rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ;
     public final void rule__Trigger__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19623:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 )
-            // InternalRoom.g:19624:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1
+            // InternalRoom.g:19852:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 )
+            // InternalRoom.g:19853:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__Trigger__Group_2__0__Impl();
@@ -53820,17 +54479,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__0__Impl"
-    // InternalRoom.g:19631:1: rule__Trigger__Group_2__0__Impl : ( '|' ) ;
+    // InternalRoom.g:19860:1: rule__Trigger__Group_2__0__Impl : ( '|' ) ;
     public final void rule__Trigger__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19635:1: ( ( '|' ) )
-            // InternalRoom.g:19636:1: ( '|' )
+            // InternalRoom.g:19864:1: ( ( '|' ) )
+            // InternalRoom.g:19865:1: ( '|' )
             {
-            // InternalRoom.g:19636:1: ( '|' )
-            // InternalRoom.g:19637:1: '|'
+            // InternalRoom.g:19865:1: ( '|' )
+            // InternalRoom.g:19866:1: '|'
             {
              before(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); 
             match(input,117,FOLLOW_2); 
@@ -53857,14 +54516,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__1"
-    // InternalRoom.g:19650:1: rule__Trigger__Group_2__1 : rule__Trigger__Group_2__1__Impl ;
+    // InternalRoom.g:19879:1: rule__Trigger__Group_2__1 : rule__Trigger__Group_2__1__Impl ;
     public final void rule__Trigger__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19654:1: ( rule__Trigger__Group_2__1__Impl )
-            // InternalRoom.g:19655:2: rule__Trigger__Group_2__1__Impl
+            // InternalRoom.g:19883:1: ( rule__Trigger__Group_2__1__Impl )
+            // InternalRoom.g:19884:2: rule__Trigger__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group_2__1__Impl();
@@ -53890,21 +54549,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group_2__1__Impl"
-    // InternalRoom.g:19661:1: rule__Trigger__Group_2__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ;
+    // InternalRoom.g:19890:1: rule__Trigger__Group_2__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ;
     public final void rule__Trigger__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19665:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) )
-            // InternalRoom.g:19666:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
+            // InternalRoom.g:19894:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) )
+            // InternalRoom.g:19895:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
             {
-            // InternalRoom.g:19666:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
-            // InternalRoom.g:19667:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
+            // InternalRoom.g:19895:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
+            // InternalRoom.g:19896:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); 
-            // InternalRoom.g:19668:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
-            // InternalRoom.g:19668:2: rule__Trigger__MsgFromIfPairsAssignment_2_1
+            // InternalRoom.g:19897:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
+            // InternalRoom.g:19897:2: rule__Trigger__MsgFromIfPairsAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_2_1();
@@ -53937,14 +54596,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__0"
-    // InternalRoom.g:19682:1: rule__MessageFromIf__Group__0 : rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ;
+    // InternalRoom.g:19911:1: rule__MessageFromIf__Group__0 : rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ;
     public final void rule__MessageFromIf__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19686:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 )
-            // InternalRoom.g:19687:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1
+            // InternalRoom.g:19915:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 )
+            // InternalRoom.g:19916:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__MessageFromIf__Group__0__Impl();
@@ -53975,21 +54634,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__0__Impl"
-    // InternalRoom.g:19694:1: rule__MessageFromIf__Group__0__Impl : ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ;
+    // InternalRoom.g:19923:1: rule__MessageFromIf__Group__0__Impl : ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ;
     public final void rule__MessageFromIf__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19698:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) )
-            // InternalRoom.g:19699:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
+            // InternalRoom.g:19927:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) )
+            // InternalRoom.g:19928:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
             {
-            // InternalRoom.g:19699:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
-            // InternalRoom.g:19700:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalRoom.g:19928:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
+            // InternalRoom.g:19929:1: ( rule__MessageFromIf__MessageAssignment_0 )
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); 
-            // InternalRoom.g:19701:1: ( rule__MessageFromIf__MessageAssignment_0 )
-            // InternalRoom.g:19701:2: rule__MessageFromIf__MessageAssignment_0
+            // InternalRoom.g:19930:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalRoom.g:19930:2: rule__MessageFromIf__MessageAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__MessageAssignment_0();
@@ -54022,14 +54681,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__1"
-    // InternalRoom.g:19711:1: rule__MessageFromIf__Group__1 : rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ;
+    // InternalRoom.g:19940:1: rule__MessageFromIf__Group__1 : rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ;
     public final void rule__MessageFromIf__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19715:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 )
-            // InternalRoom.g:19716:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2
+            // InternalRoom.g:19944:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 )
+            // InternalRoom.g:19945:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__MessageFromIf__Group__1__Impl();
@@ -54060,17 +54719,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__1__Impl"
-    // InternalRoom.g:19723:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:19952:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ;
     public final void rule__MessageFromIf__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19727:1: ( ( ':' ) )
-            // InternalRoom.g:19728:1: ( ':' )
+            // InternalRoom.g:19956:1: ( ( ':' ) )
+            // InternalRoom.g:19957:1: ( ':' )
             {
-            // InternalRoom.g:19728:1: ( ':' )
-            // InternalRoom.g:19729:1: ':'
+            // InternalRoom.g:19957:1: ( ':' )
+            // InternalRoom.g:19958:1: ':'
             {
              before(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -54097,14 +54756,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__2"
-    // InternalRoom.g:19742:1: rule__MessageFromIf__Group__2 : rule__MessageFromIf__Group__2__Impl ;
+    // InternalRoom.g:19971:1: rule__MessageFromIf__Group__2 : rule__MessageFromIf__Group__2__Impl ;
     public final void rule__MessageFromIf__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19746:1: ( rule__MessageFromIf__Group__2__Impl )
-            // InternalRoom.g:19747:2: rule__MessageFromIf__Group__2__Impl
+            // InternalRoom.g:19975:1: ( rule__MessageFromIf__Group__2__Impl )
+            // InternalRoom.g:19976:2: rule__MessageFromIf__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__2__Impl();
@@ -54130,21 +54789,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__2__Impl"
-    // InternalRoom.g:19753:1: rule__MessageFromIf__Group__2__Impl : ( ( rule__MessageFromIf__FromAssignment_2 ) ) ;
+    // InternalRoom.g:19982:1: rule__MessageFromIf__Group__2__Impl : ( ( rule__MessageFromIf__FromAssignment_2 ) ) ;
     public final void rule__MessageFromIf__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19757:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) )
-            // InternalRoom.g:19758:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
+            // InternalRoom.g:19986:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) )
+            // InternalRoom.g:19987:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
             {
-            // InternalRoom.g:19758:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
-            // InternalRoom.g:19759:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalRoom.g:19987:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
+            // InternalRoom.g:19988:1: ( rule__MessageFromIf__FromAssignment_2 )
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); 
-            // InternalRoom.g:19760:1: ( rule__MessageFromIf__FromAssignment_2 )
-            // InternalRoom.g:19760:2: rule__MessageFromIf__FromAssignment_2
+            // InternalRoom.g:19989:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalRoom.g:19989:2: rule__MessageFromIf__FromAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__FromAssignment_2();
@@ -54177,14 +54836,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__0"
-    // InternalRoom.g:19776:1: rule__Guard__Group__0 : rule__Guard__Group__0__Impl rule__Guard__Group__1 ;
+    // InternalRoom.g:20005:1: rule__Guard__Group__0 : rule__Guard__Group__0__Impl rule__Guard__Group__1 ;
     public final void rule__Guard__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19780:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 )
-            // InternalRoom.g:19781:2: rule__Guard__Group__0__Impl rule__Guard__Group__1
+            // InternalRoom.g:20009:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 )
+            // InternalRoom.g:20010:2: rule__Guard__Group__0__Impl rule__Guard__Group__1
             {
             pushFollow(FOLLOW_27);
             rule__Guard__Group__0__Impl();
@@ -54215,17 +54874,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__0__Impl"
-    // InternalRoom.g:19788:1: rule__Guard__Group__0__Impl : ( 'guard' ) ;
+    // InternalRoom.g:20017:1: rule__Guard__Group__0__Impl : ( 'guard' ) ;
     public final void rule__Guard__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19792:1: ( ( 'guard' ) )
-            // InternalRoom.g:19793:1: ( 'guard' )
+            // InternalRoom.g:20021:1: ( ( 'guard' ) )
+            // InternalRoom.g:20022:1: ( 'guard' )
             {
-            // InternalRoom.g:19793:1: ( 'guard' )
-            // InternalRoom.g:19794:1: 'guard'
+            // InternalRoom.g:20022:1: ( 'guard' )
+            // InternalRoom.g:20023:1: 'guard'
             {
              before(grammarAccess.getGuardAccess().getGuardKeyword_0()); 
             match(input,110,FOLLOW_2); 
@@ -54252,14 +54911,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__1"
-    // InternalRoom.g:19807:1: rule__Guard__Group__1 : rule__Guard__Group__1__Impl ;
+    // InternalRoom.g:20036:1: rule__Guard__Group__1 : rule__Guard__Group__1__Impl ;
     public final void rule__Guard__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19811:1: ( rule__Guard__Group__1__Impl )
-            // InternalRoom.g:19812:2: rule__Guard__Group__1__Impl
+            // InternalRoom.g:20040:1: ( rule__Guard__Group__1__Impl )
+            // InternalRoom.g:20041:2: rule__Guard__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__1__Impl();
@@ -54285,21 +54944,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__Group__1__Impl"
-    // InternalRoom.g:19818:1: rule__Guard__Group__1__Impl : ( ( rule__Guard__GuardAssignment_1 ) ) ;
+    // InternalRoom.g:20047:1: rule__Guard__Group__1__Impl : ( ( rule__Guard__GuardAssignment_1 ) ) ;
     public final void rule__Guard__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19822:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) )
-            // InternalRoom.g:19823:1: ( ( rule__Guard__GuardAssignment_1 ) )
+            // InternalRoom.g:20051:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) )
+            // InternalRoom.g:20052:1: ( ( rule__Guard__GuardAssignment_1 ) )
             {
-            // InternalRoom.g:19823:1: ( ( rule__Guard__GuardAssignment_1 ) )
-            // InternalRoom.g:19824:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalRoom.g:20052:1: ( ( rule__Guard__GuardAssignment_1 ) )
+            // InternalRoom.g:20053:1: ( rule__Guard__GuardAssignment_1 )
             {
              before(grammarAccess.getGuardAccess().getGuardAssignment_1()); 
-            // InternalRoom.g:19825:1: ( rule__Guard__GuardAssignment_1 )
-            // InternalRoom.g:19825:2: rule__Guard__GuardAssignment_1
+            // InternalRoom.g:20054:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalRoom.g:20054:2: rule__Guard__GuardAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Guard__GuardAssignment_1();
@@ -54332,16 +54991,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__0"
-    // InternalRoom.g:19839:1: rule__ProtocolSemantics__Group__0 : rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1 ;
+    // InternalRoom.g:20068:1: rule__ProtocolSemantics__Group__0 : rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1 ;
     public final void rule__ProtocolSemantics__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19843:1: ( rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1 )
-            // InternalRoom.g:19844:2: rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1
+            // InternalRoom.g:20072:1: ( rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1 )
+            // InternalRoom.g:20073:2: rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1
             {
-            pushFollow(FOLLOW_100);
+            pushFollow(FOLLOW_101);
             rule__ProtocolSemantics__Group__0__Impl();
 
             state._fsp--;
@@ -54370,21 +55029,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__0__Impl"
-    // InternalRoom.g:19851:1: rule__ProtocolSemantics__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:20080:1: rule__ProtocolSemantics__Group__0__Impl : ( () ) ;
     public final void rule__ProtocolSemantics__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19855:1: ( ( () ) )
-            // InternalRoom.g:19856:1: ( () )
+            // InternalRoom.g:20084:1: ( ( () ) )
+            // InternalRoom.g:20085:1: ( () )
             {
-            // InternalRoom.g:19856:1: ( () )
-            // InternalRoom.g:19857:1: ()
+            // InternalRoom.g:20085:1: ( () )
+            // InternalRoom.g:20086:1: ()
             {
              before(grammarAccess.getProtocolSemanticsAccess().getProtocolSemanticsAction_0()); 
-            // InternalRoom.g:19858:1: ()
-            // InternalRoom.g:19860:1: 
+            // InternalRoom.g:20087:1: ()
+            // InternalRoom.g:20089:1: 
             {
             }
 
@@ -54407,14 +55066,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__1"
-    // InternalRoom.g:19870:1: rule__ProtocolSemantics__Group__1 : rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2 ;
+    // InternalRoom.g:20099:1: rule__ProtocolSemantics__Group__1 : rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2 ;
     public final void rule__ProtocolSemantics__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19874:1: ( rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2 )
-            // InternalRoom.g:19875:2: rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2
+            // InternalRoom.g:20103:1: ( rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2 )
+            // InternalRoom.g:20104:2: rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolSemantics__Group__1__Impl();
@@ -54445,17 +55104,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__1__Impl"
-    // InternalRoom.g:19882:1: rule__ProtocolSemantics__Group__1__Impl : ( 'semantics' ) ;
+    // InternalRoom.g:20111:1: rule__ProtocolSemantics__Group__1__Impl : ( 'semantics' ) ;
     public final void rule__ProtocolSemantics__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19886:1: ( ( 'semantics' ) )
-            // InternalRoom.g:19887:1: ( 'semantics' )
+            // InternalRoom.g:20115:1: ( ( 'semantics' ) )
+            // InternalRoom.g:20116:1: ( 'semantics' )
             {
-            // InternalRoom.g:19887:1: ( 'semantics' )
-            // InternalRoom.g:19888:1: 'semantics'
+            // InternalRoom.g:20116:1: ( 'semantics' )
+            // InternalRoom.g:20117:1: 'semantics'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getSemanticsKeyword_1()); 
             match(input,118,FOLLOW_2); 
@@ -54482,16 +55141,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__2"
-    // InternalRoom.g:19901:1: rule__ProtocolSemantics__Group__2 : rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3 ;
+    // InternalRoom.g:20130:1: rule__ProtocolSemantics__Group__2 : rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3 ;
     public final void rule__ProtocolSemantics__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19905:1: ( rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3 )
-            // InternalRoom.g:19906:2: rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3
+            // InternalRoom.g:20134:1: ( rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3 )
+            // InternalRoom.g:20135:2: rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3
             {
-            pushFollow(FOLLOW_101);
+            pushFollow(FOLLOW_102);
             rule__ProtocolSemantics__Group__2__Impl();
 
             state._fsp--;
@@ -54520,17 +55179,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__2__Impl"
-    // InternalRoom.g:19913:1: rule__ProtocolSemantics__Group__2__Impl : ( '{' ) ;
+    // InternalRoom.g:20142:1: rule__ProtocolSemantics__Group__2__Impl : ( '{' ) ;
     public final void rule__ProtocolSemantics__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19917:1: ( ( '{' ) )
-            // InternalRoom.g:19918:1: ( '{' )
+            // InternalRoom.g:20146:1: ( ( '{' ) )
+            // InternalRoom.g:20147:1: ( '{' )
             {
-            // InternalRoom.g:19918:1: ( '{' )
-            // InternalRoom.g:19919:1: '{'
+            // InternalRoom.g:20147:1: ( '{' )
+            // InternalRoom.g:20148:1: '{'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getLeftCurlyBracketKeyword_2()); 
             match(input,44,FOLLOW_2); 
@@ -54557,16 +55216,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__3"
-    // InternalRoom.g:19932:1: rule__ProtocolSemantics__Group__3 : rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4 ;
+    // InternalRoom.g:20161:1: rule__ProtocolSemantics__Group__3 : rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4 ;
     public final void rule__ProtocolSemantics__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19936:1: ( rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4 )
-            // InternalRoom.g:19937:2: rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4
+            // InternalRoom.g:20165:1: ( rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4 )
+            // InternalRoom.g:20166:2: rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4
             {
-            pushFollow(FOLLOW_101);
+            pushFollow(FOLLOW_102);
             rule__ProtocolSemantics__Group__3__Impl();
 
             state._fsp--;
@@ -54595,35 +55254,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__3__Impl"
-    // InternalRoom.g:19944:1: rule__ProtocolSemantics__Group__3__Impl : ( ( rule__ProtocolSemantics__RulesAssignment_3 )* ) ;
+    // InternalRoom.g:20173:1: rule__ProtocolSemantics__Group__3__Impl : ( ( rule__ProtocolSemantics__RulesAssignment_3 )* ) ;
     public final void rule__ProtocolSemantics__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19948:1: ( ( ( rule__ProtocolSemantics__RulesAssignment_3 )* ) )
-            // InternalRoom.g:19949:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
+            // InternalRoom.g:20177:1: ( ( ( rule__ProtocolSemantics__RulesAssignment_3 )* ) )
+            // InternalRoom.g:20178:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
             {
-            // InternalRoom.g:19949:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
-            // InternalRoom.g:19950:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
+            // InternalRoom.g:20178:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
+            // InternalRoom.g:20179:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRulesAssignment_3()); 
-            // InternalRoom.g:19951:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
-            loop188:
+            // InternalRoom.g:20180:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
+            loop191:
             do {
-                int alt188=2;
-                int LA188_0 = input.LA(1);
+                int alt191=2;
+                int LA191_0 = input.LA(1);
 
-                if ( ((LA188_0>=119 && LA188_0<=120)) ) {
-                    alt188=1;
+                if ( ((LA191_0>=119 && LA191_0<=120)) ) {
+                    alt191=1;
                 }
 
 
-                switch (alt188) {
+                switch (alt191) {
             	case 1 :
-            	    // InternalRoom.g:19951:2: rule__ProtocolSemantics__RulesAssignment_3
+            	    // InternalRoom.g:20180:2: rule__ProtocolSemantics__RulesAssignment_3
             	    {
-            	    pushFollow(FOLLOW_102);
+            	    pushFollow(FOLLOW_103);
             	    rule__ProtocolSemantics__RulesAssignment_3();
 
             	    state._fsp--;
@@ -54633,7 +55292,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop188;
+            	    break loop191;
                 }
             } while (true);
 
@@ -54660,14 +55319,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__4"
-    // InternalRoom.g:19961:1: rule__ProtocolSemantics__Group__4 : rule__ProtocolSemantics__Group__4__Impl ;
+    // InternalRoom.g:20190:1: rule__ProtocolSemantics__Group__4 : rule__ProtocolSemantics__Group__4__Impl ;
     public final void rule__ProtocolSemantics__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19965:1: ( rule__ProtocolSemantics__Group__4__Impl )
-            // InternalRoom.g:19966:2: rule__ProtocolSemantics__Group__4__Impl
+            // InternalRoom.g:20194:1: ( rule__ProtocolSemantics__Group__4__Impl )
+            // InternalRoom.g:20195:2: rule__ProtocolSemantics__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolSemantics__Group__4__Impl();
@@ -54693,17 +55352,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__4__Impl"
-    // InternalRoom.g:19972:1: rule__ProtocolSemantics__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:20201:1: rule__ProtocolSemantics__Group__4__Impl : ( '}' ) ;
     public final void rule__ProtocolSemantics__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:19976:1: ( ( '}' ) )
-            // InternalRoom.g:19977:1: ( '}' )
+            // InternalRoom.g:20205:1: ( ( '}' ) )
+            // InternalRoom.g:20206:1: ( '}' )
             {
-            // InternalRoom.g:19977:1: ( '}' )
-            // InternalRoom.g:19978:1: '}'
+            // InternalRoom.g:20206:1: ( '}' )
+            // InternalRoom.g:20207:1: '}'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -54730,14 +55389,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__0"
-    // InternalRoom.g:20001:1: rule__InSemanticsRule__Group__0 : rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ;
+    // InternalRoom.g:20230:1: rule__InSemanticsRule__Group__0 : rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ;
     public final void rule__InSemanticsRule__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20005:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 )
-            // InternalRoom.g:20006:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1
+            // InternalRoom.g:20234:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 )
+            // InternalRoom.g:20235:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__InSemanticsRule__Group__0__Impl();
@@ -54768,17 +55427,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__0__Impl"
-    // InternalRoom.g:20013:1: rule__InSemanticsRule__Group__0__Impl : ( 'in' ) ;
+    // InternalRoom.g:20242:1: rule__InSemanticsRule__Group__0__Impl : ( 'in' ) ;
     public final void rule__InSemanticsRule__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20017:1: ( ( 'in' ) )
-            // InternalRoom.g:20018:1: ( 'in' )
+            // InternalRoom.g:20246:1: ( ( 'in' ) )
+            // InternalRoom.g:20247:1: ( 'in' )
             {
-            // InternalRoom.g:20018:1: ( 'in' )
-            // InternalRoom.g:20019:1: 'in'
+            // InternalRoom.g:20247:1: ( 'in' )
+            // InternalRoom.g:20248:1: 'in'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); 
             match(input,119,FOLLOW_2); 
@@ -54805,14 +55464,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__1"
-    // InternalRoom.g:20032:1: rule__InSemanticsRule__Group__1 : rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ;
+    // InternalRoom.g:20261:1: rule__InSemanticsRule__Group__1 : rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ;
     public final void rule__InSemanticsRule__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20036:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 )
-            // InternalRoom.g:20037:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2
+            // InternalRoom.g:20265:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 )
+            // InternalRoom.g:20266:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__InSemanticsRule__Group__1__Impl();
@@ -54843,17 +55502,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__1__Impl"
-    // InternalRoom.g:20044:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:20273:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ;
     public final void rule__InSemanticsRule__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20048:1: ( ( ':' ) )
-            // InternalRoom.g:20049:1: ( ':' )
+            // InternalRoom.g:20277:1: ( ( ':' ) )
+            // InternalRoom.g:20278:1: ( ':' )
             {
-            // InternalRoom.g:20049:1: ( ':' )
-            // InternalRoom.g:20050:1: ':'
+            // InternalRoom.g:20278:1: ( ':' )
+            // InternalRoom.g:20279:1: ':'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -54880,14 +55539,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__2"
-    // InternalRoom.g:20063:1: rule__InSemanticsRule__Group__2 : rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ;
+    // InternalRoom.g:20292:1: rule__InSemanticsRule__Group__2 : rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ;
     public final void rule__InSemanticsRule__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20067:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 )
-            // InternalRoom.g:20068:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3
+            // InternalRoom.g:20296:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 )
+            // InternalRoom.g:20297:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_11);
             rule__InSemanticsRule__Group__2__Impl();
@@ -54918,21 +55577,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__2__Impl"
-    // InternalRoom.g:20075:1: rule__InSemanticsRule__Group__2__Impl : ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ;
+    // InternalRoom.g:20304:1: rule__InSemanticsRule__Group__2__Impl : ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ;
     public final void rule__InSemanticsRule__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20079:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) )
-            // InternalRoom.g:20080:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20308:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalRoom.g:20309:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:20080:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
-            // InternalRoom.g:20081:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20309:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20310:1: ( rule__InSemanticsRule__MsgAssignment_2 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); 
-            // InternalRoom.g:20082:1: ( rule__InSemanticsRule__MsgAssignment_2 )
-            // InternalRoom.g:20082:2: rule__InSemanticsRule__MsgAssignment_2
+            // InternalRoom.g:20311:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20311:2: rule__InSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__MsgAssignment_2();
@@ -54965,14 +55624,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__3"
-    // InternalRoom.g:20092:1: rule__InSemanticsRule__Group__3 : rule__InSemanticsRule__Group__3__Impl ;
+    // InternalRoom.g:20321:1: rule__InSemanticsRule__Group__3 : rule__InSemanticsRule__Group__3__Impl ;
     public final void rule__InSemanticsRule__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20096:1: ( rule__InSemanticsRule__Group__3__Impl )
-            // InternalRoom.g:20097:2: rule__InSemanticsRule__Group__3__Impl
+            // InternalRoom.g:20325:1: ( rule__InSemanticsRule__Group__3__Impl )
+            // InternalRoom.g:20326:2: rule__InSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__3__Impl();
@@ -54998,29 +55657,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__3__Impl"
-    // InternalRoom.g:20103:1: rule__InSemanticsRule__Group__3__Impl : ( ( rule__InSemanticsRule__Group_3__0 )? ) ;
+    // InternalRoom.g:20332:1: rule__InSemanticsRule__Group__3__Impl : ( ( rule__InSemanticsRule__Group_3__0 )? ) ;
     public final void rule__InSemanticsRule__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20107:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) )
-            // InternalRoom.g:20108:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20336:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) )
+            // InternalRoom.g:20337:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
             {
-            // InternalRoom.g:20108:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
-            // InternalRoom.g:20109:1: ( rule__InSemanticsRule__Group_3__0 )?
+            // InternalRoom.g:20337:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20338:1: ( rule__InSemanticsRule__Group_3__0 )?
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); 
-            // InternalRoom.g:20110:1: ( rule__InSemanticsRule__Group_3__0 )?
-            int alt189=2;
-            int LA189_0 = input.LA(1);
+            // InternalRoom.g:20339:1: ( rule__InSemanticsRule__Group_3__0 )?
+            int alt192=2;
+            int LA192_0 = input.LA(1);
 
-            if ( (LA189_0==48) ) {
-                alt189=1;
+            if ( (LA192_0==48) ) {
+                alt192=1;
             }
-            switch (alt189) {
+            switch (alt192) {
                 case 1 :
-                    // InternalRoom.g:20110:2: rule__InSemanticsRule__Group_3__0
+                    // InternalRoom.g:20339:2: rule__InSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3__0();
@@ -55056,16 +55715,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__0"
-    // InternalRoom.g:20128:1: rule__InSemanticsRule__Group_3__0 : rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ;
+    // InternalRoom.g:20357:1: rule__InSemanticsRule__Group_3__0 : rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ;
     public final void rule__InSemanticsRule__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20132:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 )
-            // InternalRoom.g:20133:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1
+            // InternalRoom.g:20361:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 )
+            // InternalRoom.g:20362:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1
             {
-            pushFollow(FOLLOW_103);
+            pushFollow(FOLLOW_104);
             rule__InSemanticsRule__Group_3__0__Impl();
 
             state._fsp--;
@@ -55094,17 +55753,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__0__Impl"
-    // InternalRoom.g:20140:1: rule__InSemanticsRule__Group_3__0__Impl : ( '->' ) ;
+    // InternalRoom.g:20369:1: rule__InSemanticsRule__Group_3__0__Impl : ( '->' ) ;
     public final void rule__InSemanticsRule__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20144:1: ( ( '->' ) )
-            // InternalRoom.g:20145:1: ( '->' )
+            // InternalRoom.g:20373:1: ( ( '->' ) )
+            // InternalRoom.g:20374:1: ( '->' )
             {
-            // InternalRoom.g:20145:1: ( '->' )
-            // InternalRoom.g:20146:1: '->'
+            // InternalRoom.g:20374:1: ( '->' )
+            // InternalRoom.g:20375:1: '->'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,48,FOLLOW_2); 
@@ -55131,14 +55790,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__1"
-    // InternalRoom.g:20159:1: rule__InSemanticsRule__Group_3__1 : rule__InSemanticsRule__Group_3__1__Impl ;
+    // InternalRoom.g:20388:1: rule__InSemanticsRule__Group_3__1 : rule__InSemanticsRule__Group_3__1__Impl ;
     public final void rule__InSemanticsRule__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20163:1: ( rule__InSemanticsRule__Group_3__1__Impl )
-            // InternalRoom.g:20164:2: rule__InSemanticsRule__Group_3__1__Impl
+            // InternalRoom.g:20392:1: ( rule__InSemanticsRule__Group_3__1__Impl )
+            // InternalRoom.g:20393:2: rule__InSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3__1__Impl();
@@ -55164,21 +55823,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3__1__Impl"
-    // InternalRoom.g:20170:1: rule__InSemanticsRule__Group_3__1__Impl : ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ;
+    // InternalRoom.g:20399:1: rule__InSemanticsRule__Group_3__1__Impl : ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20174:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) )
-            // InternalRoom.g:20175:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20403:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalRoom.g:20404:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
             {
-            // InternalRoom.g:20175:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
-            // InternalRoom.g:20176:1: ( rule__InSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20404:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20405:1: ( rule__InSemanticsRule__Alternatives_3_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); 
-            // InternalRoom.g:20177:1: ( rule__InSemanticsRule__Alternatives_3_1 )
-            // InternalRoom.g:20177:2: rule__InSemanticsRule__Alternatives_3_1
+            // InternalRoom.g:20406:1: ( rule__InSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20406:2: rule__InSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Alternatives_3_1();
@@ -55211,16 +55870,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0"
-    // InternalRoom.g:20191:1: rule__InSemanticsRule__Group_3_1_1__0 : rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ;
+    // InternalRoom.g:20420:1: rule__InSemanticsRule__Group_3_1_1__0 : rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ;
     public final void rule__InSemanticsRule__Group_3_1_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20195:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 )
-            // InternalRoom.g:20196:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1
+            // InternalRoom.g:20424:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 )
+            // InternalRoom.g:20425:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1
             {
-            pushFollow(FOLLOW_104);
+            pushFollow(FOLLOW_105);
             rule__InSemanticsRule__Group_3_1_1__0__Impl();
 
             state._fsp--;
@@ -55249,17 +55908,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0__Impl"
-    // InternalRoom.g:20203:1: rule__InSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
+    // InternalRoom.g:20432:1: rule__InSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20207:1: ( ( '(' ) )
-            // InternalRoom.g:20208:1: ( '(' )
+            // InternalRoom.g:20436:1: ( ( '(' ) )
+            // InternalRoom.g:20437:1: ( '(' )
             {
-            // InternalRoom.g:20208:1: ( '(' )
-            // InternalRoom.g:20209:1: '('
+            // InternalRoom.g:20437:1: ( '(' )
+            // InternalRoom.g:20438:1: '('
             {
              before(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,50,FOLLOW_2); 
@@ -55286,14 +55945,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1"
-    // InternalRoom.g:20222:1: rule__InSemanticsRule__Group_3_1_1__1 : rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ;
+    // InternalRoom.g:20451:1: rule__InSemanticsRule__Group_3_1_1__1 : rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ;
     public final void rule__InSemanticsRule__Group_3_1_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20226:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 )
-            // InternalRoom.g:20227:2: rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2
+            // InternalRoom.g:20455:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 )
+            // InternalRoom.g:20456:2: rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2
             {
             pushFollow(FOLLOW_18);
             rule__InSemanticsRule__Group_3_1_1__1__Impl();
@@ -55324,21 +55983,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1__Impl"
-    // InternalRoom.g:20234:1: rule__InSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
+    // InternalRoom.g:20463:1: rule__InSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20238:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
-            // InternalRoom.g:20239:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20467:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalRoom.g:20468:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
             {
-            // InternalRoom.g:20239:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
-            // InternalRoom.g:20240:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20468:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20469:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); 
-            // InternalRoom.g:20241:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
-            // InternalRoom.g:20241:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
+            // InternalRoom.g:20470:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20470:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -55371,14 +56030,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2"
-    // InternalRoom.g:20251:1: rule__InSemanticsRule__Group_3_1_1__2 : rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ;
+    // InternalRoom.g:20480:1: rule__InSemanticsRule__Group_3_1_1__2 : rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ;
     public final void rule__InSemanticsRule__Group_3_1_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20255:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 )
-            // InternalRoom.g:20256:2: rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3
+            // InternalRoom.g:20484:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 )
+            // InternalRoom.g:20485:2: rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3
             {
             pushFollow(FOLLOW_15);
             rule__InSemanticsRule__Group_3_1_1__2__Impl();
@@ -55409,24 +56068,24 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2__Impl"
-    // InternalRoom.g:20263:1: rule__InSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
+    // InternalRoom.g:20492:1: rule__InSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20267:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) )
-            // InternalRoom.g:20268:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20496:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalRoom.g:20497:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
             {
-            // InternalRoom.g:20268:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
-            // InternalRoom.g:20269:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20497:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20498:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
             {
-            // InternalRoom.g:20269:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) )
-            // InternalRoom.g:20270:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20498:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalRoom.g:20499:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalRoom.g:20271:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
-            // InternalRoom.g:20271:2: rule__InSemanticsRule__Group_3_1_1_2__0
+            // InternalRoom.g:20500:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20500:2: rule__InSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_19);
             rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -55440,24 +56099,24 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             }
 
-            // InternalRoom.g:20274:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
-            // InternalRoom.g:20275:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
+            // InternalRoom.g:20503:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20504:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
             {
              before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalRoom.g:20276:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
-            loop190:
+            // InternalRoom.g:20505:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
+            loop193:
             do {
-                int alt190=2;
-                int LA190_0 = input.LA(1);
+                int alt193=2;
+                int LA193_0 = input.LA(1);
 
-                if ( (LA190_0==54) ) {
-                    alt190=1;
+                if ( (LA193_0==54) ) {
+                    alt193=1;
                 }
 
 
-                switch (alt190) {
+                switch (alt193) {
             	case 1 :
-            	    // InternalRoom.g:20276:2: rule__InSemanticsRule__Group_3_1_1_2__0
+            	    // InternalRoom.g:20505:2: rule__InSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -55469,7 +56128,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop190;
+            	    break loop193;
                 }
             } while (true);
 
@@ -55499,14 +56158,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3"
-    // InternalRoom.g:20287:1: rule__InSemanticsRule__Group_3_1_1__3 : rule__InSemanticsRule__Group_3_1_1__3__Impl ;
+    // InternalRoom.g:20516:1: rule__InSemanticsRule__Group_3_1_1__3 : rule__InSemanticsRule__Group_3_1_1__3__Impl ;
     public final void rule__InSemanticsRule__Group_3_1_1__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20291:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl )
-            // InternalRoom.g:20292:2: rule__InSemanticsRule__Group_3_1_1__3__Impl
+            // InternalRoom.g:20520:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalRoom.g:20521:2: rule__InSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1__3__Impl();
@@ -55532,17 +56191,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3__Impl"
-    // InternalRoom.g:20298:1: rule__InSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
+    // InternalRoom.g:20527:1: rule__InSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20302:1: ( ( ')' ) )
-            // InternalRoom.g:20303:1: ( ')' )
+            // InternalRoom.g:20531:1: ( ( ')' ) )
+            // InternalRoom.g:20532:1: ( ')' )
             {
-            // InternalRoom.g:20303:1: ( ')' )
-            // InternalRoom.g:20304:1: ')'
+            // InternalRoom.g:20532:1: ( ')' )
+            // InternalRoom.g:20533:1: ')'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,51,FOLLOW_2); 
@@ -55569,16 +56228,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0"
-    // InternalRoom.g:20325:1: rule__InSemanticsRule__Group_3_1_1_2__0 : rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ;
+    // InternalRoom.g:20554:1: rule__InSemanticsRule__Group_3_1_1_2__0 : rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20329:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 )
-            // InternalRoom.g:20330:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1
+            // InternalRoom.g:20558:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 )
+            // InternalRoom.g:20559:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1
             {
-            pushFollow(FOLLOW_104);
+            pushFollow(FOLLOW_105);
             rule__InSemanticsRule__Group_3_1_1_2__0__Impl();
 
             state._fsp--;
@@ -55607,17 +56266,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0__Impl"
-    // InternalRoom.g:20337:1: rule__InSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
+    // InternalRoom.g:20566:1: rule__InSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20341:1: ( ( ',' ) )
-            // InternalRoom.g:20342:1: ( ',' )
+            // InternalRoom.g:20570:1: ( ( ',' ) )
+            // InternalRoom.g:20571:1: ( ',' )
             {
-            // InternalRoom.g:20342:1: ( ',' )
-            // InternalRoom.g:20343:1: ','
+            // InternalRoom.g:20571:1: ( ',' )
+            // InternalRoom.g:20572:1: ','
             {
              before(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -55644,14 +56303,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1"
-    // InternalRoom.g:20356:1: rule__InSemanticsRule__Group_3_1_1_2__1 : rule__InSemanticsRule__Group_3_1_1_2__1__Impl ;
+    // InternalRoom.g:20585:1: rule__InSemanticsRule__Group_3_1_1_2__1 : rule__InSemanticsRule__Group_3_1_1_2__1__Impl ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20360:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl )
-            // InternalRoom.g:20361:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl
+            // InternalRoom.g:20589:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalRoom.g:20590:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -55677,21 +56336,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1__Impl"
-    // InternalRoom.g:20367:1: rule__InSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
+    // InternalRoom.g:20596:1: rule__InSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
     public final void rule__InSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20371:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
-            // InternalRoom.g:20372:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20600:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalRoom.g:20601:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
             {
-            // InternalRoom.g:20372:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
-            // InternalRoom.g:20373:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20601:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20602:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); 
-            // InternalRoom.g:20374:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
-            // InternalRoom.g:20374:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
+            // InternalRoom.g:20603:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20603:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -55724,14 +56383,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__0"
-    // InternalRoom.g:20388:1: rule__OutSemanticsRule__Group__0 : rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ;
+    // InternalRoom.g:20617:1: rule__OutSemanticsRule__Group__0 : rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ;
     public final void rule__OutSemanticsRule__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20392:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 )
-            // InternalRoom.g:20393:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1
+            // InternalRoom.g:20621:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 )
+            // InternalRoom.g:20622:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__OutSemanticsRule__Group__0__Impl();
@@ -55762,17 +56421,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__0__Impl"
-    // InternalRoom.g:20400:1: rule__OutSemanticsRule__Group__0__Impl : ( 'out' ) ;
+    // InternalRoom.g:20629:1: rule__OutSemanticsRule__Group__0__Impl : ( 'out' ) ;
     public final void rule__OutSemanticsRule__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20404:1: ( ( 'out' ) )
-            // InternalRoom.g:20405:1: ( 'out' )
+            // InternalRoom.g:20633:1: ( ( 'out' ) )
+            // InternalRoom.g:20634:1: ( 'out' )
             {
-            // InternalRoom.g:20405:1: ( 'out' )
-            // InternalRoom.g:20406:1: 'out'
+            // InternalRoom.g:20634:1: ( 'out' )
+            // InternalRoom.g:20635:1: 'out'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); 
             match(input,120,FOLLOW_2); 
@@ -55799,14 +56458,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__1"
-    // InternalRoom.g:20419:1: rule__OutSemanticsRule__Group__1 : rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ;
+    // InternalRoom.g:20648:1: rule__OutSemanticsRule__Group__1 : rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ;
     public final void rule__OutSemanticsRule__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20423:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 )
-            // InternalRoom.g:20424:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2
+            // InternalRoom.g:20652:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 )
+            // InternalRoom.g:20653:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__OutSemanticsRule__Group__1__Impl();
@@ -55837,17 +56496,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__1__Impl"
-    // InternalRoom.g:20431:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:20660:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ;
     public final void rule__OutSemanticsRule__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20435:1: ( ( ':' ) )
-            // InternalRoom.g:20436:1: ( ':' )
+            // InternalRoom.g:20664:1: ( ( ':' ) )
+            // InternalRoom.g:20665:1: ( ':' )
             {
-            // InternalRoom.g:20436:1: ( ':' )
-            // InternalRoom.g:20437:1: ':'
+            // InternalRoom.g:20665:1: ( ':' )
+            // InternalRoom.g:20666:1: ':'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -55874,14 +56533,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__2"
-    // InternalRoom.g:20450:1: rule__OutSemanticsRule__Group__2 : rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ;
+    // InternalRoom.g:20679:1: rule__OutSemanticsRule__Group__2 : rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ;
     public final void rule__OutSemanticsRule__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20454:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 )
-            // InternalRoom.g:20455:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3
+            // InternalRoom.g:20683:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 )
+            // InternalRoom.g:20684:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_11);
             rule__OutSemanticsRule__Group__2__Impl();
@@ -55912,21 +56571,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__2__Impl"
-    // InternalRoom.g:20462:1: rule__OutSemanticsRule__Group__2__Impl : ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ;
+    // InternalRoom.g:20691:1: rule__OutSemanticsRule__Group__2__Impl : ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ;
     public final void rule__OutSemanticsRule__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20466:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) )
-            // InternalRoom.g:20467:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20695:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalRoom.g:20696:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:20467:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
-            // InternalRoom.g:20468:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20696:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20697:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); 
-            // InternalRoom.g:20469:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
-            // InternalRoom.g:20469:2: rule__OutSemanticsRule__MsgAssignment_2
+            // InternalRoom.g:20698:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20698:2: rule__OutSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__MsgAssignment_2();
@@ -55959,14 +56618,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__3"
-    // InternalRoom.g:20479:1: rule__OutSemanticsRule__Group__3 : rule__OutSemanticsRule__Group__3__Impl ;
+    // InternalRoom.g:20708:1: rule__OutSemanticsRule__Group__3 : rule__OutSemanticsRule__Group__3__Impl ;
     public final void rule__OutSemanticsRule__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20483:1: ( rule__OutSemanticsRule__Group__3__Impl )
-            // InternalRoom.g:20484:2: rule__OutSemanticsRule__Group__3__Impl
+            // InternalRoom.g:20712:1: ( rule__OutSemanticsRule__Group__3__Impl )
+            // InternalRoom.g:20713:2: rule__OutSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__3__Impl();
@@ -55992,29 +56651,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__3__Impl"
-    // InternalRoom.g:20490:1: rule__OutSemanticsRule__Group__3__Impl : ( ( rule__OutSemanticsRule__Group_3__0 )? ) ;
+    // InternalRoom.g:20719:1: rule__OutSemanticsRule__Group__3__Impl : ( ( rule__OutSemanticsRule__Group_3__0 )? ) ;
     public final void rule__OutSemanticsRule__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20494:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) )
-            // InternalRoom.g:20495:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20723:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) )
+            // InternalRoom.g:20724:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
             {
-            // InternalRoom.g:20495:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
-            // InternalRoom.g:20496:1: ( rule__OutSemanticsRule__Group_3__0 )?
+            // InternalRoom.g:20724:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20725:1: ( rule__OutSemanticsRule__Group_3__0 )?
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); 
-            // InternalRoom.g:20497:1: ( rule__OutSemanticsRule__Group_3__0 )?
-            int alt191=2;
-            int LA191_0 = input.LA(1);
+            // InternalRoom.g:20726:1: ( rule__OutSemanticsRule__Group_3__0 )?
+            int alt194=2;
+            int LA194_0 = input.LA(1);
 
-            if ( (LA191_0==48) ) {
-                alt191=1;
+            if ( (LA194_0==48) ) {
+                alt194=1;
             }
-            switch (alt191) {
+            switch (alt194) {
                 case 1 :
-                    // InternalRoom.g:20497:2: rule__OutSemanticsRule__Group_3__0
+                    // InternalRoom.g:20726:2: rule__OutSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3__0();
@@ -56050,16 +56709,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__0"
-    // InternalRoom.g:20515:1: rule__OutSemanticsRule__Group_3__0 : rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ;
+    // InternalRoom.g:20744:1: rule__OutSemanticsRule__Group_3__0 : rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ;
     public final void rule__OutSemanticsRule__Group_3__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20519:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 )
-            // InternalRoom.g:20520:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1
+            // InternalRoom.g:20748:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 )
+            // InternalRoom.g:20749:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1
             {
-            pushFollow(FOLLOW_103);
+            pushFollow(FOLLOW_104);
             rule__OutSemanticsRule__Group_3__0__Impl();
 
             state._fsp--;
@@ -56088,17 +56747,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__0__Impl"
-    // InternalRoom.g:20527:1: rule__OutSemanticsRule__Group_3__0__Impl : ( '->' ) ;
+    // InternalRoom.g:20756:1: rule__OutSemanticsRule__Group_3__0__Impl : ( '->' ) ;
     public final void rule__OutSemanticsRule__Group_3__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20531:1: ( ( '->' ) )
-            // InternalRoom.g:20532:1: ( '->' )
+            // InternalRoom.g:20760:1: ( ( '->' ) )
+            // InternalRoom.g:20761:1: ( '->' )
             {
-            // InternalRoom.g:20532:1: ( '->' )
-            // InternalRoom.g:20533:1: '->'
+            // InternalRoom.g:20761:1: ( '->' )
+            // InternalRoom.g:20762:1: '->'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,48,FOLLOW_2); 
@@ -56125,14 +56784,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__1"
-    // InternalRoom.g:20546:1: rule__OutSemanticsRule__Group_3__1 : rule__OutSemanticsRule__Group_3__1__Impl ;
+    // InternalRoom.g:20775:1: rule__OutSemanticsRule__Group_3__1 : rule__OutSemanticsRule__Group_3__1__Impl ;
     public final void rule__OutSemanticsRule__Group_3__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20550:1: ( rule__OutSemanticsRule__Group_3__1__Impl )
-            // InternalRoom.g:20551:2: rule__OutSemanticsRule__Group_3__1__Impl
+            // InternalRoom.g:20779:1: ( rule__OutSemanticsRule__Group_3__1__Impl )
+            // InternalRoom.g:20780:2: rule__OutSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3__1__Impl();
@@ -56158,21 +56817,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3__1__Impl"
-    // InternalRoom.g:20557:1: rule__OutSemanticsRule__Group_3__1__Impl : ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ;
+    // InternalRoom.g:20786:1: rule__OutSemanticsRule__Group_3__1__Impl : ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20561:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) )
-            // InternalRoom.g:20562:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20790:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalRoom.g:20791:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
             {
-            // InternalRoom.g:20562:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
-            // InternalRoom.g:20563:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20791:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20792:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); 
-            // InternalRoom.g:20564:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
-            // InternalRoom.g:20564:2: rule__OutSemanticsRule__Alternatives_3_1
+            // InternalRoom.g:20793:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20793:2: rule__OutSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Alternatives_3_1();
@@ -56205,16 +56864,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0"
-    // InternalRoom.g:20578:1: rule__OutSemanticsRule__Group_3_1_1__0 : rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ;
+    // InternalRoom.g:20807:1: rule__OutSemanticsRule__Group_3_1_1__0 : rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20582:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 )
-            // InternalRoom.g:20583:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1
+            // InternalRoom.g:20811:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 )
+            // InternalRoom.g:20812:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1
             {
-            pushFollow(FOLLOW_104);
+            pushFollow(FOLLOW_105);
             rule__OutSemanticsRule__Group_3_1_1__0__Impl();
 
             state._fsp--;
@@ -56243,17 +56902,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0__Impl"
-    // InternalRoom.g:20590:1: rule__OutSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
+    // InternalRoom.g:20819:1: rule__OutSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20594:1: ( ( '(' ) )
-            // InternalRoom.g:20595:1: ( '(' )
+            // InternalRoom.g:20823:1: ( ( '(' ) )
+            // InternalRoom.g:20824:1: ( '(' )
             {
-            // InternalRoom.g:20595:1: ( '(' )
-            // InternalRoom.g:20596:1: '('
+            // InternalRoom.g:20824:1: ( '(' )
+            // InternalRoom.g:20825:1: '('
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,50,FOLLOW_2); 
@@ -56280,14 +56939,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1"
-    // InternalRoom.g:20609:1: rule__OutSemanticsRule__Group_3_1_1__1 : rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ;
+    // InternalRoom.g:20838:1: rule__OutSemanticsRule__Group_3_1_1__1 : rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20613:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 )
-            // InternalRoom.g:20614:2: rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2
+            // InternalRoom.g:20842:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 )
+            // InternalRoom.g:20843:2: rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2
             {
             pushFollow(FOLLOW_18);
             rule__OutSemanticsRule__Group_3_1_1__1__Impl();
@@ -56318,21 +56977,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1__Impl"
-    // InternalRoom.g:20621:1: rule__OutSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
+    // InternalRoom.g:20850:1: rule__OutSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20625:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
-            // InternalRoom.g:20626:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20854:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalRoom.g:20855:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
             {
-            // InternalRoom.g:20626:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
-            // InternalRoom.g:20627:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20855:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20856:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); 
-            // InternalRoom.g:20628:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
-            // InternalRoom.g:20628:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
+            // InternalRoom.g:20857:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20857:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -56365,14 +57024,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2"
-    // InternalRoom.g:20638:1: rule__OutSemanticsRule__Group_3_1_1__2 : rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ;
+    // InternalRoom.g:20867:1: rule__OutSemanticsRule__Group_3_1_1__2 : rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ;
     public final void rule__OutSemanticsRule__Group_3_1_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20642:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 )
-            // InternalRoom.g:20643:2: rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3
+            // InternalRoom.g:20871:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 )
+            // InternalRoom.g:20872:2: rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3
             {
             pushFollow(FOLLOW_15);
             rule__OutSemanticsRule__Group_3_1_1__2__Impl();
@@ -56403,24 +57062,24 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2__Impl"
-    // InternalRoom.g:20650:1: rule__OutSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
+    // InternalRoom.g:20879:1: rule__OutSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20654:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) )
-            // InternalRoom.g:20655:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20883:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalRoom.g:20884:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
             {
-            // InternalRoom.g:20655:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
-            // InternalRoom.g:20656:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20884:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20885:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
             {
-            // InternalRoom.g:20656:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) )
-            // InternalRoom.g:20657:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20885:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalRoom.g:20886:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalRoom.g:20658:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
-            // InternalRoom.g:20658:2: rule__OutSemanticsRule__Group_3_1_1_2__0
+            // InternalRoom.g:20887:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20887:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_19);
             rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -56434,24 +57093,24 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             }
 
-            // InternalRoom.g:20661:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
-            // InternalRoom.g:20662:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
+            // InternalRoom.g:20890:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20891:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); 
-            // InternalRoom.g:20663:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
-            loop192:
+            // InternalRoom.g:20892:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
+            loop195:
             do {
-                int alt192=2;
-                int LA192_0 = input.LA(1);
+                int alt195=2;
+                int LA195_0 = input.LA(1);
 
-                if ( (LA192_0==54) ) {
-                    alt192=1;
+                if ( (LA195_0==54) ) {
+                    alt195=1;
                 }
 
 
-                switch (alt192) {
+                switch (alt195) {
             	case 1 :
-            	    // InternalRoom.g:20663:2: rule__OutSemanticsRule__Group_3_1_1_2__0
+            	    // InternalRoom.g:20892:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -56463,7 +57122,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop192;
+            	    break loop195;
                 }
             } while (true);
 
@@ -56493,14 +57152,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3"
-    // InternalRoom.g:20674:1: rule__OutSemanticsRule__Group_3_1_1__3 : rule__OutSemanticsRule__Group_3_1_1__3__Impl ;
+    // InternalRoom.g:20903:1: rule__OutSemanticsRule__Group_3_1_1__3 : rule__OutSemanticsRule__Group_3_1_1__3__Impl ;
     public final void rule__OutSemanticsRule__Group_3_1_1__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20678:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl )
-            // InternalRoom.g:20679:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl
+            // InternalRoom.g:20907:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalRoom.g:20908:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1__3__Impl();
@@ -56526,17 +57185,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3__Impl"
-    // InternalRoom.g:20685:1: rule__OutSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
+    // InternalRoom.g:20914:1: rule__OutSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20689:1: ( ( ')' ) )
-            // InternalRoom.g:20690:1: ( ')' )
+            // InternalRoom.g:20918:1: ( ( ')' ) )
+            // InternalRoom.g:20919:1: ( ')' )
             {
-            // InternalRoom.g:20690:1: ( ')' )
-            // InternalRoom.g:20691:1: ')'
+            // InternalRoom.g:20919:1: ( ')' )
+            // InternalRoom.g:20920:1: ')'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,51,FOLLOW_2); 
@@ -56563,16 +57222,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0"
-    // InternalRoom.g:20712:1: rule__OutSemanticsRule__Group_3_1_1_2__0 : rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ;
+    // InternalRoom.g:20941:1: rule__OutSemanticsRule__Group_3_1_1_2__0 : rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20716:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 )
-            // InternalRoom.g:20717:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1
+            // InternalRoom.g:20945:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 )
+            // InternalRoom.g:20946:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1
             {
-            pushFollow(FOLLOW_104);
+            pushFollow(FOLLOW_105);
             rule__OutSemanticsRule__Group_3_1_1_2__0__Impl();
 
             state._fsp--;
@@ -56601,17 +57260,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0__Impl"
-    // InternalRoom.g:20724:1: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
+    // InternalRoom.g:20953:1: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20728:1: ( ( ',' ) )
-            // InternalRoom.g:20729:1: ( ',' )
+            // InternalRoom.g:20957:1: ( ( ',' ) )
+            // InternalRoom.g:20958:1: ( ',' )
             {
-            // InternalRoom.g:20729:1: ( ',' )
-            // InternalRoom.g:20730:1: ','
+            // InternalRoom.g:20958:1: ( ',' )
+            // InternalRoom.g:20959:1: ','
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -56638,14 +57297,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1"
-    // InternalRoom.g:20743:1: rule__OutSemanticsRule__Group_3_1_1_2__1 : rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ;
+    // InternalRoom.g:20972:1: rule__OutSemanticsRule__Group_3_1_1_2__1 : rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20747:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl )
-            // InternalRoom.g:20748:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
+            // InternalRoom.g:20976:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalRoom.g:20977:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -56671,21 +57330,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1__Impl"
-    // InternalRoom.g:20754:1: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
+    // InternalRoom.g:20983:1: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ;
     public final void rule__OutSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20758:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
-            // InternalRoom.g:20759:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20987:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalRoom.g:20988:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
             {
-            // InternalRoom.g:20759:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
-            // InternalRoom.g:20760:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20988:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20989:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); 
-            // InternalRoom.g:20761:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
-            // InternalRoom.g:20761:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
+            // InternalRoom.g:20990:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20990:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -56718,14 +57377,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__0"
-    // InternalRoom.g:20775:1: rule__Annotation__Group__0 : rule__Annotation__Group__0__Impl rule__Annotation__Group__1 ;
+    // InternalRoom.g:21004:1: rule__Annotation__Group__0 : rule__Annotation__Group__0__Impl rule__Annotation__Group__1 ;
     public final void rule__Annotation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20779:1: ( rule__Annotation__Group__0__Impl rule__Annotation__Group__1 )
-            // InternalRoom.g:20780:2: rule__Annotation__Group__0__Impl rule__Annotation__Group__1
+            // InternalRoom.g:21008:1: ( rule__Annotation__Group__0__Impl rule__Annotation__Group__1 )
+            // InternalRoom.g:21009:2: rule__Annotation__Group__0__Impl rule__Annotation__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Annotation__Group__0__Impl();
@@ -56756,17 +57415,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__0__Impl"
-    // InternalRoom.g:20787:1: rule__Annotation__Group__0__Impl : ( '@' ) ;
+    // InternalRoom.g:21016:1: rule__Annotation__Group__0__Impl : ( '@' ) ;
     public final void rule__Annotation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20791:1: ( ( '@' ) )
-            // InternalRoom.g:20792:1: ( '@' )
+            // InternalRoom.g:21020:1: ( ( '@' ) )
+            // InternalRoom.g:21021:1: ( '@' )
             {
-            // InternalRoom.g:20792:1: ( '@' )
-            // InternalRoom.g:20793:1: '@'
+            // InternalRoom.g:21021:1: ( '@' )
+            // InternalRoom.g:21022:1: '@'
             {
              before(grammarAccess.getAnnotationAccess().getCommercialAtKeyword_0()); 
             match(input,121,FOLLOW_2); 
@@ -56793,14 +57452,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__1"
-    // InternalRoom.g:20806:1: rule__Annotation__Group__1 : rule__Annotation__Group__1__Impl rule__Annotation__Group__2 ;
+    // InternalRoom.g:21035:1: rule__Annotation__Group__1 : rule__Annotation__Group__1__Impl rule__Annotation__Group__2 ;
     public final void rule__Annotation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20810:1: ( rule__Annotation__Group__1__Impl rule__Annotation__Group__2 )
-            // InternalRoom.g:20811:2: rule__Annotation__Group__1__Impl rule__Annotation__Group__2
+            // InternalRoom.g:21039:1: ( rule__Annotation__Group__1__Impl rule__Annotation__Group__2 )
+            // InternalRoom.g:21040:2: rule__Annotation__Group__1__Impl rule__Annotation__Group__2
             {
             pushFollow(FOLLOW_33);
             rule__Annotation__Group__1__Impl();
@@ -56831,21 +57490,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__1__Impl"
-    // InternalRoom.g:20818:1: rule__Annotation__Group__1__Impl : ( ( rule__Annotation__TypeAssignment_1 ) ) ;
+    // InternalRoom.g:21047:1: rule__Annotation__Group__1__Impl : ( ( rule__Annotation__TypeAssignment_1 ) ) ;
     public final void rule__Annotation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20822:1: ( ( ( rule__Annotation__TypeAssignment_1 ) ) )
-            // InternalRoom.g:20823:1: ( ( rule__Annotation__TypeAssignment_1 ) )
+            // InternalRoom.g:21051:1: ( ( ( rule__Annotation__TypeAssignment_1 ) ) )
+            // InternalRoom.g:21052:1: ( ( rule__Annotation__TypeAssignment_1 ) )
             {
-            // InternalRoom.g:20823:1: ( ( rule__Annotation__TypeAssignment_1 ) )
-            // InternalRoom.g:20824:1: ( rule__Annotation__TypeAssignment_1 )
+            // InternalRoom.g:21052:1: ( ( rule__Annotation__TypeAssignment_1 ) )
+            // InternalRoom.g:21053:1: ( rule__Annotation__TypeAssignment_1 )
             {
              before(grammarAccess.getAnnotationAccess().getTypeAssignment_1()); 
-            // InternalRoom.g:20825:1: ( rule__Annotation__TypeAssignment_1 )
-            // InternalRoom.g:20825:2: rule__Annotation__TypeAssignment_1
+            // InternalRoom.g:21054:1: ( rule__Annotation__TypeAssignment_1 )
+            // InternalRoom.g:21054:2: rule__Annotation__TypeAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__TypeAssignment_1();
@@ -56878,14 +57537,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__2"
-    // InternalRoom.g:20835:1: rule__Annotation__Group__2 : rule__Annotation__Group__2__Impl ;
+    // InternalRoom.g:21064:1: rule__Annotation__Group__2 : rule__Annotation__Group__2__Impl ;
     public final void rule__Annotation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20839:1: ( rule__Annotation__Group__2__Impl )
-            // InternalRoom.g:20840:2: rule__Annotation__Group__2__Impl
+            // InternalRoom.g:21068:1: ( rule__Annotation__Group__2__Impl )
+            // InternalRoom.g:21069:2: rule__Annotation__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group__2__Impl();
@@ -56911,29 +57570,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__2__Impl"
-    // InternalRoom.g:20846:1: rule__Annotation__Group__2__Impl : ( ( rule__Annotation__Group_2__0 )? ) ;
+    // InternalRoom.g:21075:1: rule__Annotation__Group__2__Impl : ( ( rule__Annotation__Group_2__0 )? ) ;
     public final void rule__Annotation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20850:1: ( ( ( rule__Annotation__Group_2__0 )? ) )
-            // InternalRoom.g:20851:1: ( ( rule__Annotation__Group_2__0 )? )
+            // InternalRoom.g:21079:1: ( ( ( rule__Annotation__Group_2__0 )? ) )
+            // InternalRoom.g:21080:1: ( ( rule__Annotation__Group_2__0 )? )
             {
-            // InternalRoom.g:20851:1: ( ( rule__Annotation__Group_2__0 )? )
-            // InternalRoom.g:20852:1: ( rule__Annotation__Group_2__0 )?
+            // InternalRoom.g:21080:1: ( ( rule__Annotation__Group_2__0 )? )
+            // InternalRoom.g:21081:1: ( rule__Annotation__Group_2__0 )?
             {
              before(grammarAccess.getAnnotationAccess().getGroup_2()); 
-            // InternalRoom.g:20853:1: ( rule__Annotation__Group_2__0 )?
-            int alt193=2;
-            int LA193_0 = input.LA(1);
+            // InternalRoom.g:21082:1: ( rule__Annotation__Group_2__0 )?
+            int alt196=2;
+            int LA196_0 = input.LA(1);
 
-            if ( (LA193_0==50) ) {
-                alt193=1;
+            if ( (LA196_0==50) ) {
+                alt196=1;
             }
-            switch (alt193) {
+            switch (alt196) {
                 case 1 :
-                    // InternalRoom.g:20853:2: rule__Annotation__Group_2__0
+                    // InternalRoom.g:21082:2: rule__Annotation__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Annotation__Group_2__0();
@@ -56969,14 +57628,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__0"
-    // InternalRoom.g:20869:1: rule__Annotation__Group_2__0 : rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1 ;
+    // InternalRoom.g:21098:1: rule__Annotation__Group_2__0 : rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1 ;
     public final void rule__Annotation__Group_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20873:1: ( rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1 )
-            // InternalRoom.g:20874:2: rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1
+            // InternalRoom.g:21102:1: ( rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1 )
+            // InternalRoom.g:21103:2: rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__Annotation__Group_2__0__Impl();
@@ -57007,17 +57666,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__0__Impl"
-    // InternalRoom.g:20881:1: rule__Annotation__Group_2__0__Impl : ( '(' ) ;
+    // InternalRoom.g:21110:1: rule__Annotation__Group_2__0__Impl : ( '(' ) ;
     public final void rule__Annotation__Group_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20885:1: ( ( '(' ) )
-            // InternalRoom.g:20886:1: ( '(' )
+            // InternalRoom.g:21114:1: ( ( '(' ) )
+            // InternalRoom.g:21115:1: ( '(' )
             {
-            // InternalRoom.g:20886:1: ( '(' )
-            // InternalRoom.g:20887:1: '('
+            // InternalRoom.g:21115:1: ( '(' )
+            // InternalRoom.g:21116:1: '('
             {
              before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_2_0()); 
             match(input,50,FOLLOW_2); 
@@ -57044,16 +57703,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__1"
-    // InternalRoom.g:20900:1: rule__Annotation__Group_2__1 : rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2 ;
+    // InternalRoom.g:21129:1: rule__Annotation__Group_2__1 : rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2 ;
     public final void rule__Annotation__Group_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20904:1: ( rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2 )
-            // InternalRoom.g:20905:2: rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2
+            // InternalRoom.g:21133:1: ( rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2 )
+            // InternalRoom.g:21134:2: rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2
             {
-            pushFollow(FOLLOW_105);
+            pushFollow(FOLLOW_106);
             rule__Annotation__Group_2__1__Impl();
 
             state._fsp--;
@@ -57082,21 +57741,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__1__Impl"
-    // InternalRoom.g:20912:1: rule__Annotation__Group_2__1__Impl : ( ( rule__Annotation__AttributesAssignment_2_1 ) ) ;
+    // InternalRoom.g:21141:1: rule__Annotation__Group_2__1__Impl : ( ( rule__Annotation__AttributesAssignment_2_1 ) ) ;
     public final void rule__Annotation__Group_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20916:1: ( ( ( rule__Annotation__AttributesAssignment_2_1 ) ) )
-            // InternalRoom.g:20917:1: ( ( rule__Annotation__AttributesAssignment_2_1 ) )
+            // InternalRoom.g:21145:1: ( ( ( rule__Annotation__AttributesAssignment_2_1 ) ) )
+            // InternalRoom.g:21146:1: ( ( rule__Annotation__AttributesAssignment_2_1 ) )
             {
-            // InternalRoom.g:20917:1: ( ( rule__Annotation__AttributesAssignment_2_1 ) )
-            // InternalRoom.g:20918:1: ( rule__Annotation__AttributesAssignment_2_1 )
+            // InternalRoom.g:21146:1: ( ( rule__Annotation__AttributesAssignment_2_1 ) )
+            // InternalRoom.g:21147:1: ( rule__Annotation__AttributesAssignment_2_1 )
             {
              before(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_1()); 
-            // InternalRoom.g:20919:1: ( rule__Annotation__AttributesAssignment_2_1 )
-            // InternalRoom.g:20919:2: rule__Annotation__AttributesAssignment_2_1
+            // InternalRoom.g:21148:1: ( rule__Annotation__AttributesAssignment_2_1 )
+            // InternalRoom.g:21148:2: rule__Annotation__AttributesAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__AttributesAssignment_2_1();
@@ -57129,16 +57788,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__2"
-    // InternalRoom.g:20929:1: rule__Annotation__Group_2__2 : rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3 ;
+    // InternalRoom.g:21158:1: rule__Annotation__Group_2__2 : rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3 ;
     public final void rule__Annotation__Group_2__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20933:1: ( rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3 )
-            // InternalRoom.g:20934:2: rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3
+            // InternalRoom.g:21162:1: ( rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3 )
+            // InternalRoom.g:21163:2: rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3
             {
-            pushFollow(FOLLOW_105);
+            pushFollow(FOLLOW_106);
             rule__Annotation__Group_2__2__Impl();
 
             state._fsp--;
@@ -57167,33 +57826,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__2__Impl"
-    // InternalRoom.g:20941:1: rule__Annotation__Group_2__2__Impl : ( ( rule__Annotation__Group_2_2__0 )* ) ;
+    // InternalRoom.g:21170:1: rule__Annotation__Group_2__2__Impl : ( ( rule__Annotation__Group_2_2__0 )* ) ;
     public final void rule__Annotation__Group_2__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20945:1: ( ( ( rule__Annotation__Group_2_2__0 )* ) )
-            // InternalRoom.g:20946:1: ( ( rule__Annotation__Group_2_2__0 )* )
+            // InternalRoom.g:21174:1: ( ( ( rule__Annotation__Group_2_2__0 )* ) )
+            // InternalRoom.g:21175:1: ( ( rule__Annotation__Group_2_2__0 )* )
             {
-            // InternalRoom.g:20946:1: ( ( rule__Annotation__Group_2_2__0 )* )
-            // InternalRoom.g:20947:1: ( rule__Annotation__Group_2_2__0 )*
+            // InternalRoom.g:21175:1: ( ( rule__Annotation__Group_2_2__0 )* )
+            // InternalRoom.g:21176:1: ( rule__Annotation__Group_2_2__0 )*
             {
              before(grammarAccess.getAnnotationAccess().getGroup_2_2()); 
-            // InternalRoom.g:20948:1: ( rule__Annotation__Group_2_2__0 )*
-            loop194:
+            // InternalRoom.g:21177:1: ( rule__Annotation__Group_2_2__0 )*
+            loop197:
             do {
-                int alt194=2;
-                int LA194_0 = input.LA(1);
+                int alt197=2;
+                int LA197_0 = input.LA(1);
 
-                if ( (LA194_0==54) ) {
-                    alt194=1;
+                if ( (LA197_0==54) ) {
+                    alt197=1;
                 }
 
 
-                switch (alt194) {
+                switch (alt197) {
             	case 1 :
-            	    // InternalRoom.g:20948:2: rule__Annotation__Group_2_2__0
+            	    // InternalRoom.g:21177:2: rule__Annotation__Group_2_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__Annotation__Group_2_2__0();
@@ -57205,7 +57864,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop194;
+            	    break loop197;
                 }
             } while (true);
 
@@ -57232,14 +57891,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__3"
-    // InternalRoom.g:20958:1: rule__Annotation__Group_2__3 : rule__Annotation__Group_2__3__Impl ;
+    // InternalRoom.g:21187:1: rule__Annotation__Group_2__3 : rule__Annotation__Group_2__3__Impl ;
     public final void rule__Annotation__Group_2__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20962:1: ( rule__Annotation__Group_2__3__Impl )
-            // InternalRoom.g:20963:2: rule__Annotation__Group_2__3__Impl
+            // InternalRoom.g:21191:1: ( rule__Annotation__Group_2__3__Impl )
+            // InternalRoom.g:21192:2: rule__Annotation__Group_2__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group_2__3__Impl();
@@ -57265,17 +57924,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2__3__Impl"
-    // InternalRoom.g:20969:1: rule__Annotation__Group_2__3__Impl : ( ')' ) ;
+    // InternalRoom.g:21198:1: rule__Annotation__Group_2__3__Impl : ( ')' ) ;
     public final void rule__Annotation__Group_2__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:20973:1: ( ( ')' ) )
-            // InternalRoom.g:20974:1: ( ')' )
+            // InternalRoom.g:21202:1: ( ( ')' ) )
+            // InternalRoom.g:21203:1: ( ')' )
             {
-            // InternalRoom.g:20974:1: ( ')' )
-            // InternalRoom.g:20975:1: ')'
+            // InternalRoom.g:21203:1: ( ')' )
+            // InternalRoom.g:21204:1: ')'
             {
              before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_2_3()); 
             match(input,51,FOLLOW_2); 
@@ -57302,14 +57961,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2_2__0"
-    // InternalRoom.g:20996:1: rule__Annotation__Group_2_2__0 : rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1 ;
+    // InternalRoom.g:21225:1: rule__Annotation__Group_2_2__0 : rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1 ;
     public final void rule__Annotation__Group_2_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21000:1: ( rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1 )
-            // InternalRoom.g:21001:2: rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1
+            // InternalRoom.g:21229:1: ( rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1 )
+            // InternalRoom.g:21230:2: rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1
             {
             pushFollow(FOLLOW_3);
             rule__Annotation__Group_2_2__0__Impl();
@@ -57340,17 +57999,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2_2__0__Impl"
-    // InternalRoom.g:21008:1: rule__Annotation__Group_2_2__0__Impl : ( ',' ) ;
+    // InternalRoom.g:21237:1: rule__Annotation__Group_2_2__0__Impl : ( ',' ) ;
     public final void rule__Annotation__Group_2_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21012:1: ( ( ',' ) )
-            // InternalRoom.g:21013:1: ( ',' )
+            // InternalRoom.g:21241:1: ( ( ',' ) )
+            // InternalRoom.g:21242:1: ( ',' )
             {
-            // InternalRoom.g:21013:1: ( ',' )
-            // InternalRoom.g:21014:1: ','
+            // InternalRoom.g:21242:1: ( ',' )
+            // InternalRoom.g:21243:1: ','
             {
              before(grammarAccess.getAnnotationAccess().getCommaKeyword_2_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -57377,14 +58036,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2_2__1"
-    // InternalRoom.g:21027:1: rule__Annotation__Group_2_2__1 : rule__Annotation__Group_2_2__1__Impl ;
+    // InternalRoom.g:21256:1: rule__Annotation__Group_2_2__1 : rule__Annotation__Group_2_2__1__Impl ;
     public final void rule__Annotation__Group_2_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21031:1: ( rule__Annotation__Group_2_2__1__Impl )
-            // InternalRoom.g:21032:2: rule__Annotation__Group_2_2__1__Impl
+            // InternalRoom.g:21260:1: ( rule__Annotation__Group_2_2__1__Impl )
+            // InternalRoom.g:21261:2: rule__Annotation__Group_2_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group_2_2__1__Impl();
@@ -57410,21 +58069,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group_2_2__1__Impl"
-    // InternalRoom.g:21038:1: rule__Annotation__Group_2_2__1__Impl : ( ( rule__Annotation__AttributesAssignment_2_2_1 ) ) ;
+    // InternalRoom.g:21267:1: rule__Annotation__Group_2_2__1__Impl : ( ( rule__Annotation__AttributesAssignment_2_2_1 ) ) ;
     public final void rule__Annotation__Group_2_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21042:1: ( ( ( rule__Annotation__AttributesAssignment_2_2_1 ) ) )
-            // InternalRoom.g:21043:1: ( ( rule__Annotation__AttributesAssignment_2_2_1 ) )
+            // InternalRoom.g:21271:1: ( ( ( rule__Annotation__AttributesAssignment_2_2_1 ) ) )
+            // InternalRoom.g:21272:1: ( ( rule__Annotation__AttributesAssignment_2_2_1 ) )
             {
-            // InternalRoom.g:21043:1: ( ( rule__Annotation__AttributesAssignment_2_2_1 ) )
-            // InternalRoom.g:21044:1: ( rule__Annotation__AttributesAssignment_2_2_1 )
+            // InternalRoom.g:21272:1: ( ( rule__Annotation__AttributesAssignment_2_2_1 ) )
+            // InternalRoom.g:21273:1: ( rule__Annotation__AttributesAssignment_2_2_1 )
             {
              before(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_2_1()); 
-            // InternalRoom.g:21045:1: ( rule__Annotation__AttributesAssignment_2_2_1 )
-            // InternalRoom.g:21045:2: rule__Annotation__AttributesAssignment_2_2_1
+            // InternalRoom.g:21274:1: ( rule__Annotation__AttributesAssignment_2_2_1 )
+            // InternalRoom.g:21274:2: rule__Annotation__AttributesAssignment_2_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__AttributesAssignment_2_2_1();
@@ -57457,14 +58116,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__0"
-    // InternalRoom.g:21059:1: rule__KeyValue__Group__0 : rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ;
+    // InternalRoom.g:21288:1: rule__KeyValue__Group__0 : rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ;
     public final void rule__KeyValue__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21063:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 )
-            // InternalRoom.g:21064:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1
+            // InternalRoom.g:21292:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 )
+            // InternalRoom.g:21293:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1
             {
             pushFollow(FOLLOW_20);
             rule__KeyValue__Group__0__Impl();
@@ -57495,21 +58154,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__0__Impl"
-    // InternalRoom.g:21071:1: rule__KeyValue__Group__0__Impl : ( ( rule__KeyValue__KeyAssignment_0 ) ) ;
+    // InternalRoom.g:21300:1: rule__KeyValue__Group__0__Impl : ( ( rule__KeyValue__KeyAssignment_0 ) ) ;
     public final void rule__KeyValue__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21075:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) )
-            // InternalRoom.g:21076:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
+            // InternalRoom.g:21304:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) )
+            // InternalRoom.g:21305:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
             {
-            // InternalRoom.g:21076:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
-            // InternalRoom.g:21077:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalRoom.g:21305:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
+            // InternalRoom.g:21306:1: ( rule__KeyValue__KeyAssignment_0 )
             {
              before(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); 
-            // InternalRoom.g:21078:1: ( rule__KeyValue__KeyAssignment_0 )
-            // InternalRoom.g:21078:2: rule__KeyValue__KeyAssignment_0
+            // InternalRoom.g:21307:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalRoom.g:21307:2: rule__KeyValue__KeyAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__KeyAssignment_0();
@@ -57542,16 +58201,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__1"
-    // InternalRoom.g:21088:1: rule__KeyValue__Group__1 : rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ;
+    // InternalRoom.g:21317:1: rule__KeyValue__Group__1 : rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ;
     public final void rule__KeyValue__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21092:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 )
-            // InternalRoom.g:21093:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2
+            // InternalRoom.g:21321:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 )
+            // InternalRoom.g:21322:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2
             {
-            pushFollow(FOLLOW_106);
+            pushFollow(FOLLOW_107);
             rule__KeyValue__Group__1__Impl();
 
             state._fsp--;
@@ -57580,17 +58239,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__1__Impl"
-    // InternalRoom.g:21100:1: rule__KeyValue__Group__1__Impl : ( '=' ) ;
+    // InternalRoom.g:21329:1: rule__KeyValue__Group__1__Impl : ( '=' ) ;
     public final void rule__KeyValue__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21104:1: ( ( '=' ) )
-            // InternalRoom.g:21105:1: ( '=' )
+            // InternalRoom.g:21333:1: ( ( '=' ) )
+            // InternalRoom.g:21334:1: ( '=' )
             {
-            // InternalRoom.g:21105:1: ( '=' )
-            // InternalRoom.g:21106:1: '='
+            // InternalRoom.g:21334:1: ( '=' )
+            // InternalRoom.g:21335:1: '='
             {
              before(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); 
             match(input,55,FOLLOW_2); 
@@ -57617,14 +58276,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__2"
-    // InternalRoom.g:21119:1: rule__KeyValue__Group__2 : rule__KeyValue__Group__2__Impl ;
+    // InternalRoom.g:21348:1: rule__KeyValue__Group__2 : rule__KeyValue__Group__2__Impl ;
     public final void rule__KeyValue__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21123:1: ( rule__KeyValue__Group__2__Impl )
-            // InternalRoom.g:21124:2: rule__KeyValue__Group__2__Impl
+            // InternalRoom.g:21352:1: ( rule__KeyValue__Group__2__Impl )
+            // InternalRoom.g:21353:2: rule__KeyValue__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__2__Impl();
@@ -57650,21 +58309,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__2__Impl"
-    // InternalRoom.g:21130:1: rule__KeyValue__Group__2__Impl : ( ( rule__KeyValue__ValueAssignment_2 ) ) ;
+    // InternalRoom.g:21359:1: rule__KeyValue__Group__2__Impl : ( ( rule__KeyValue__ValueAssignment_2 ) ) ;
     public final void rule__KeyValue__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21134:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) )
-            // InternalRoom.g:21135:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
+            // InternalRoom.g:21363:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) )
+            // InternalRoom.g:21364:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
             {
-            // InternalRoom.g:21135:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
-            // InternalRoom.g:21136:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalRoom.g:21364:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
+            // InternalRoom.g:21365:1: ( rule__KeyValue__ValueAssignment_2 )
             {
              before(grammarAccess.getKeyValueAccess().getValueAssignment_2()); 
-            // InternalRoom.g:21137:1: ( rule__KeyValue__ValueAssignment_2 )
-            // InternalRoom.g:21137:2: rule__KeyValue__ValueAssignment_2
+            // InternalRoom.g:21366:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalRoom.g:21366:2: rule__KeyValue__ValueAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__ValueAssignment_2();
@@ -57697,14 +58356,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__0"
-    // InternalRoom.g:21153:1: rule__AnnotationType__Group__0 : rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1 ;
+    // InternalRoom.g:21382:1: rule__AnnotationType__Group__0 : rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1 ;
     public final void rule__AnnotationType__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21157:1: ( rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1 )
-            // InternalRoom.g:21158:2: rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1
+            // InternalRoom.g:21386:1: ( rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1 )
+            // InternalRoom.g:21387:2: rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__AnnotationType__Group__0__Impl();
@@ -57735,17 +58394,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__0__Impl"
-    // InternalRoom.g:21165:1: rule__AnnotationType__Group__0__Impl : ( 'AnnotationType' ) ;
+    // InternalRoom.g:21394:1: rule__AnnotationType__Group__0__Impl : ( 'AnnotationType' ) ;
     public final void rule__AnnotationType__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21169:1: ( ( 'AnnotationType' ) )
-            // InternalRoom.g:21170:1: ( 'AnnotationType' )
+            // InternalRoom.g:21398:1: ( ( 'AnnotationType' ) )
+            // InternalRoom.g:21399:1: ( 'AnnotationType' )
             {
-            // InternalRoom.g:21170:1: ( 'AnnotationType' )
-            // InternalRoom.g:21171:1: 'AnnotationType'
+            // InternalRoom.g:21399:1: ( 'AnnotationType' )
+            // InternalRoom.g:21400:1: 'AnnotationType'
             {
              before(grammarAccess.getAnnotationTypeAccess().getAnnotationTypeKeyword_0()); 
             match(input,122,FOLLOW_2); 
@@ -57772,14 +58431,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__1"
-    // InternalRoom.g:21184:1: rule__AnnotationType__Group__1 : rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2 ;
+    // InternalRoom.g:21413:1: rule__AnnotationType__Group__1 : rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2 ;
     public final void rule__AnnotationType__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21188:1: ( rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2 )
-            // InternalRoom.g:21189:2: rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2
+            // InternalRoom.g:21417:1: ( rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2 )
+            // InternalRoom.g:21418:2: rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__AnnotationType__Group__1__Impl();
@@ -57810,21 +58469,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__1__Impl"
-    // InternalRoom.g:21196:1: rule__AnnotationType__Group__1__Impl : ( ( rule__AnnotationType__NameAssignment_1 ) ) ;
+    // InternalRoom.g:21425:1: rule__AnnotationType__Group__1__Impl : ( ( rule__AnnotationType__NameAssignment_1 ) ) ;
     public final void rule__AnnotationType__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21200:1: ( ( ( rule__AnnotationType__NameAssignment_1 ) ) )
-            // InternalRoom.g:21201:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
+            // InternalRoom.g:21429:1: ( ( ( rule__AnnotationType__NameAssignment_1 ) ) )
+            // InternalRoom.g:21430:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:21201:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
-            // InternalRoom.g:21202:1: ( rule__AnnotationType__NameAssignment_1 )
+            // InternalRoom.g:21430:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
+            // InternalRoom.g:21431:1: ( rule__AnnotationType__NameAssignment_1 )
             {
              before(grammarAccess.getAnnotationTypeAccess().getNameAssignment_1()); 
-            // InternalRoom.g:21203:1: ( rule__AnnotationType__NameAssignment_1 )
-            // InternalRoom.g:21203:2: rule__AnnotationType__NameAssignment_1
+            // InternalRoom.g:21432:1: ( rule__AnnotationType__NameAssignment_1 )
+            // InternalRoom.g:21432:2: rule__AnnotationType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__NameAssignment_1();
@@ -57857,14 +58516,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__2"
-    // InternalRoom.g:21213:1: rule__AnnotationType__Group__2 : rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3 ;
+    // InternalRoom.g:21442:1: rule__AnnotationType__Group__2 : rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3 ;
     public final void rule__AnnotationType__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21217:1: ( rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3 )
-            // InternalRoom.g:21218:2: rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3
+            // InternalRoom.g:21446:1: ( rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3 )
+            // InternalRoom.g:21447:2: rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__AnnotationType__Group__2__Impl();
@@ -57895,29 +58554,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__2__Impl"
-    // InternalRoom.g:21225:1: rule__AnnotationType__Group__2__Impl : ( ( rule__AnnotationType__DocuAssignment_2 )? ) ;
+    // InternalRoom.g:21454:1: rule__AnnotationType__Group__2__Impl : ( ( rule__AnnotationType__DocuAssignment_2 )? ) ;
     public final void rule__AnnotationType__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21229:1: ( ( ( rule__AnnotationType__DocuAssignment_2 )? ) )
-            // InternalRoom.g:21230:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
+            // InternalRoom.g:21458:1: ( ( ( rule__AnnotationType__DocuAssignment_2 )? ) )
+            // InternalRoom.g:21459:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:21230:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
-            // InternalRoom.g:21231:1: ( rule__AnnotationType__DocuAssignment_2 )?
+            // InternalRoom.g:21459:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
+            // InternalRoom.g:21460:1: ( rule__AnnotationType__DocuAssignment_2 )?
             {
              before(grammarAccess.getAnnotationTypeAccess().getDocuAssignment_2()); 
-            // InternalRoom.g:21232:1: ( rule__AnnotationType__DocuAssignment_2 )?
-            int alt195=2;
-            int LA195_0 = input.LA(1);
+            // InternalRoom.g:21461:1: ( rule__AnnotationType__DocuAssignment_2 )?
+            int alt198=2;
+            int LA198_0 = input.LA(1);
 
-            if ( (LA195_0==62) ) {
-                alt195=1;
+            if ( (LA198_0==62) ) {
+                alt198=1;
             }
-            switch (alt195) {
+            switch (alt198) {
                 case 1 :
-                    // InternalRoom.g:21232:2: rule__AnnotationType__DocuAssignment_2
+                    // InternalRoom.g:21461:2: rule__AnnotationType__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__DocuAssignment_2();
@@ -57953,16 +58612,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__3"
-    // InternalRoom.g:21242:1: rule__AnnotationType__Group__3 : rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4 ;
+    // InternalRoom.g:21471:1: rule__AnnotationType__Group__3 : rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4 ;
     public final void rule__AnnotationType__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21246:1: ( rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4 )
-            // InternalRoom.g:21247:2: rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4
+            // InternalRoom.g:21475:1: ( rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4 )
+            // InternalRoom.g:21476:2: rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4
             {
-            pushFollow(FOLLOW_107);
+            pushFollow(FOLLOW_108);
             rule__AnnotationType__Group__3__Impl();
 
             state._fsp--;
@@ -57991,17 +58650,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__3__Impl"
-    // InternalRoom.g:21254:1: rule__AnnotationType__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:21483:1: rule__AnnotationType__Group__3__Impl : ( '{' ) ;
     public final void rule__AnnotationType__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21258:1: ( ( '{' ) )
-            // InternalRoom.g:21259:1: ( '{' )
+            // InternalRoom.g:21487:1: ( ( '{' ) )
+            // InternalRoom.g:21488:1: ( '{' )
             {
-            // InternalRoom.g:21259:1: ( '{' )
-            // InternalRoom.g:21260:1: '{'
+            // InternalRoom.g:21488:1: ( '{' )
+            // InternalRoom.g:21489:1: '{'
             {
              before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -58028,14 +58687,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__4"
-    // InternalRoom.g:21273:1: rule__AnnotationType__Group__4 : rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5 ;
+    // InternalRoom.g:21502:1: rule__AnnotationType__Group__4 : rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5 ;
     public final void rule__AnnotationType__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21277:1: ( rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5 )
-            // InternalRoom.g:21278:2: rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5
+            // InternalRoom.g:21506:1: ( rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5 )
+            // InternalRoom.g:21507:2: rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5
             {
             pushFollow(FOLLOW_20);
             rule__AnnotationType__Group__4__Impl();
@@ -58066,17 +58725,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__4__Impl"
-    // InternalRoom.g:21285:1: rule__AnnotationType__Group__4__Impl : ( 'target' ) ;
+    // InternalRoom.g:21514:1: rule__AnnotationType__Group__4__Impl : ( 'target' ) ;
     public final void rule__AnnotationType__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21289:1: ( ( 'target' ) )
-            // InternalRoom.g:21290:1: ( 'target' )
+            // InternalRoom.g:21518:1: ( ( 'target' ) )
+            // InternalRoom.g:21519:1: ( 'target' )
             {
-            // InternalRoom.g:21290:1: ( 'target' )
-            // InternalRoom.g:21291:1: 'target'
+            // InternalRoom.g:21519:1: ( 'target' )
+            // InternalRoom.g:21520:1: 'target'
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetKeyword_4()); 
             match(input,123,FOLLOW_2); 
@@ -58103,16 +58762,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__5"
-    // InternalRoom.g:21304:1: rule__AnnotationType__Group__5 : rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6 ;
+    // InternalRoom.g:21533:1: rule__AnnotationType__Group__5 : rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6 ;
     public final void rule__AnnotationType__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21308:1: ( rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6 )
-            // InternalRoom.g:21309:2: rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6
+            // InternalRoom.g:21537:1: ( rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6 )
+            // InternalRoom.g:21538:2: rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6
             {
-            pushFollow(FOLLOW_108);
+            pushFollow(FOLLOW_109);
             rule__AnnotationType__Group__5__Impl();
 
             state._fsp--;
@@ -58141,17 +58800,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__5__Impl"
-    // InternalRoom.g:21316:1: rule__AnnotationType__Group__5__Impl : ( '=' ) ;
+    // InternalRoom.g:21545:1: rule__AnnotationType__Group__5__Impl : ( '=' ) ;
     public final void rule__AnnotationType__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21320:1: ( ( '=' ) )
-            // InternalRoom.g:21321:1: ( '=' )
+            // InternalRoom.g:21549:1: ( ( '=' ) )
+            // InternalRoom.g:21550:1: ( '=' )
             {
-            // InternalRoom.g:21321:1: ( '=' )
-            // InternalRoom.g:21322:1: '='
+            // InternalRoom.g:21550:1: ( '=' )
+            // InternalRoom.g:21551:1: '='
             {
              before(grammarAccess.getAnnotationTypeAccess().getEqualsSignKeyword_5()); 
             match(input,55,FOLLOW_2); 
@@ -58178,16 +58837,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__6"
-    // InternalRoom.g:21335:1: rule__AnnotationType__Group__6 : rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7 ;
+    // InternalRoom.g:21564:1: rule__AnnotationType__Group__6 : rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7 ;
     public final void rule__AnnotationType__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21339:1: ( rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7 )
-            // InternalRoom.g:21340:2: rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7
+            // InternalRoom.g:21568:1: ( rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7 )
+            // InternalRoom.g:21569:2: rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7
             {
-            pushFollow(FOLLOW_109);
+            pushFollow(FOLLOW_110);
             rule__AnnotationType__Group__6__Impl();
 
             state._fsp--;
@@ -58216,21 +58875,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__6__Impl"
-    // InternalRoom.g:21347:1: rule__AnnotationType__Group__6__Impl : ( ( rule__AnnotationType__Alternatives_6 ) ) ;
+    // InternalRoom.g:21576:1: rule__AnnotationType__Group__6__Impl : ( ( rule__AnnotationType__Alternatives_6 ) ) ;
     public final void rule__AnnotationType__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21351:1: ( ( ( rule__AnnotationType__Alternatives_6 ) ) )
-            // InternalRoom.g:21352:1: ( ( rule__AnnotationType__Alternatives_6 ) )
+            // InternalRoom.g:21580:1: ( ( ( rule__AnnotationType__Alternatives_6 ) ) )
+            // InternalRoom.g:21581:1: ( ( rule__AnnotationType__Alternatives_6 ) )
             {
-            // InternalRoom.g:21352:1: ( ( rule__AnnotationType__Alternatives_6 ) )
-            // InternalRoom.g:21353:1: ( rule__AnnotationType__Alternatives_6 )
+            // InternalRoom.g:21581:1: ( ( rule__AnnotationType__Alternatives_6 ) )
+            // InternalRoom.g:21582:1: ( rule__AnnotationType__Alternatives_6 )
             {
              before(grammarAccess.getAnnotationTypeAccess().getAlternatives_6()); 
-            // InternalRoom.g:21354:1: ( rule__AnnotationType__Alternatives_6 )
-            // InternalRoom.g:21354:2: rule__AnnotationType__Alternatives_6
+            // InternalRoom.g:21583:1: ( rule__AnnotationType__Alternatives_6 )
+            // InternalRoom.g:21583:2: rule__AnnotationType__Alternatives_6
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Alternatives_6();
@@ -58263,16 +58922,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__7"
-    // InternalRoom.g:21364:1: rule__AnnotationType__Group__7 : rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8 ;
+    // InternalRoom.g:21593:1: rule__AnnotationType__Group__7 : rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8 ;
     public final void rule__AnnotationType__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21368:1: ( rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8 )
-            // InternalRoom.g:21369:2: rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8
+            // InternalRoom.g:21597:1: ( rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8 )
+            // InternalRoom.g:21598:2: rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8
             {
-            pushFollow(FOLLOW_109);
+            pushFollow(FOLLOW_110);
             rule__AnnotationType__Group__7__Impl();
 
             state._fsp--;
@@ -58301,35 +58960,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__7__Impl"
-    // InternalRoom.g:21376:1: rule__AnnotationType__Group__7__Impl : ( ( rule__AnnotationType__AttributesAssignment_7 )* ) ;
+    // InternalRoom.g:21605:1: rule__AnnotationType__Group__7__Impl : ( ( rule__AnnotationType__AttributesAssignment_7 )* ) ;
     public final void rule__AnnotationType__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21380:1: ( ( ( rule__AnnotationType__AttributesAssignment_7 )* ) )
-            // InternalRoom.g:21381:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
+            // InternalRoom.g:21609:1: ( ( ( rule__AnnotationType__AttributesAssignment_7 )* ) )
+            // InternalRoom.g:21610:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
             {
-            // InternalRoom.g:21381:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
-            // InternalRoom.g:21382:1: ( rule__AnnotationType__AttributesAssignment_7 )*
+            // InternalRoom.g:21610:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
+            // InternalRoom.g:21611:1: ( rule__AnnotationType__AttributesAssignment_7 )*
             {
              before(grammarAccess.getAnnotationTypeAccess().getAttributesAssignment_7()); 
-            // InternalRoom.g:21383:1: ( rule__AnnotationType__AttributesAssignment_7 )*
-            loop196:
+            // InternalRoom.g:21612:1: ( rule__AnnotationType__AttributesAssignment_7 )*
+            loop199:
             do {
-                int alt196=2;
-                int LA196_0 = input.LA(1);
+                int alt199=2;
+                int LA199_0 = input.LA(1);
 
-                if ( (LA196_0==26||LA196_0==37) ) {
-                    alt196=1;
+                if ( (LA199_0==26||LA199_0==37) ) {
+                    alt199=1;
                 }
 
 
-                switch (alt196) {
+                switch (alt199) {
             	case 1 :
-            	    // InternalRoom.g:21383:2: rule__AnnotationType__AttributesAssignment_7
+            	    // InternalRoom.g:21612:2: rule__AnnotationType__AttributesAssignment_7
             	    {
-            	    pushFollow(FOLLOW_110);
+            	    pushFollow(FOLLOW_111);
             	    rule__AnnotationType__AttributesAssignment_7();
 
             	    state._fsp--;
@@ -58339,7 +58998,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop196;
+            	    break loop199;
                 }
             } while (true);
 
@@ -58366,14 +59025,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__8"
-    // InternalRoom.g:21393:1: rule__AnnotationType__Group__8 : rule__AnnotationType__Group__8__Impl ;
+    // InternalRoom.g:21622:1: rule__AnnotationType__Group__8 : rule__AnnotationType__Group__8__Impl ;
     public final void rule__AnnotationType__Group__8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21397:1: ( rule__AnnotationType__Group__8__Impl )
-            // InternalRoom.g:21398:2: rule__AnnotationType__Group__8__Impl
+            // InternalRoom.g:21626:1: ( rule__AnnotationType__Group__8__Impl )
+            // InternalRoom.g:21627:2: rule__AnnotationType__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group__8__Impl();
@@ -58399,17 +59058,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__8__Impl"
-    // InternalRoom.g:21404:1: rule__AnnotationType__Group__8__Impl : ( '}' ) ;
+    // InternalRoom.g:21633:1: rule__AnnotationType__Group__8__Impl : ( '}' ) ;
     public final void rule__AnnotationType__Group__8__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21408:1: ( ( '}' ) )
-            // InternalRoom.g:21409:1: ( '}' )
+            // InternalRoom.g:21637:1: ( ( '}' ) )
+            // InternalRoom.g:21638:1: ( '}' )
             {
-            // InternalRoom.g:21409:1: ( '}' )
-            // InternalRoom.g:21410:1: '}'
+            // InternalRoom.g:21638:1: ( '}' )
+            // InternalRoom.g:21639:1: '}'
             {
              before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_8()); 
             match(input,45,FOLLOW_2); 
@@ -58436,16 +59095,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__0"
-    // InternalRoom.g:21441:1: rule__AnnotationType__Group_6_1__0 : rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1 ;
+    // InternalRoom.g:21670:1: rule__AnnotationType__Group_6_1__0 : rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1 ;
     public final void rule__AnnotationType__Group_6_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21445:1: ( rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1 )
-            // InternalRoom.g:21446:2: rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1
+            // InternalRoom.g:21674:1: ( rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1 )
+            // InternalRoom.g:21675:2: rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1
             {
-            pushFollow(FOLLOW_111);
+            pushFollow(FOLLOW_112);
             rule__AnnotationType__Group_6_1__0__Impl();
 
             state._fsp--;
@@ -58474,17 +59133,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__0__Impl"
-    // InternalRoom.g:21453:1: rule__AnnotationType__Group_6_1__0__Impl : ( '{' ) ;
+    // InternalRoom.g:21682:1: rule__AnnotationType__Group_6_1__0__Impl : ( '{' ) ;
     public final void rule__AnnotationType__Group_6_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21457:1: ( ( '{' ) )
-            // InternalRoom.g:21458:1: ( '{' )
+            // InternalRoom.g:21686:1: ( ( '{' ) )
+            // InternalRoom.g:21687:1: ( '{' )
             {
-            // InternalRoom.g:21458:1: ( '{' )
-            // InternalRoom.g:21459:1: '{'
+            // InternalRoom.g:21687:1: ( '{' )
+            // InternalRoom.g:21688:1: '{'
             {
              before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_6_1_0()); 
             match(input,44,FOLLOW_2); 
@@ -58511,16 +59170,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__1"
-    // InternalRoom.g:21472:1: rule__AnnotationType__Group_6_1__1 : rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2 ;
+    // InternalRoom.g:21701:1: rule__AnnotationType__Group_6_1__1 : rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2 ;
     public final void rule__AnnotationType__Group_6_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21476:1: ( rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2 )
-            // InternalRoom.g:21477:2: rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2
+            // InternalRoom.g:21705:1: ( rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2 )
+            // InternalRoom.g:21706:2: rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2
             {
-            pushFollow(FOLLOW_112);
+            pushFollow(FOLLOW_113);
             rule__AnnotationType__Group_6_1__1__Impl();
 
             state._fsp--;
@@ -58549,21 +59208,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__1__Impl"
-    // InternalRoom.g:21484:1: rule__AnnotationType__Group_6_1__1__Impl : ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) ) ;
+    // InternalRoom.g:21713:1: rule__AnnotationType__Group_6_1__1__Impl : ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) ) ;
     public final void rule__AnnotationType__Group_6_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21488:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) ) )
-            // InternalRoom.g:21489:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) )
+            // InternalRoom.g:21717:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) ) )
+            // InternalRoom.g:21718:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) )
             {
-            // InternalRoom.g:21489:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) )
-            // InternalRoom.g:21490:1: ( rule__AnnotationType__TargetsAssignment_6_1_1 )
+            // InternalRoom.g:21718:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) )
+            // InternalRoom.g:21719:1: ( rule__AnnotationType__TargetsAssignment_6_1_1 )
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_1()); 
-            // InternalRoom.g:21491:1: ( rule__AnnotationType__TargetsAssignment_6_1_1 )
-            // InternalRoom.g:21491:2: rule__AnnotationType__TargetsAssignment_6_1_1
+            // InternalRoom.g:21720:1: ( rule__AnnotationType__TargetsAssignment_6_1_1 )
+            // InternalRoom.g:21720:2: rule__AnnotationType__TargetsAssignment_6_1_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__TargetsAssignment_6_1_1();
@@ -58596,16 +59255,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__2"
-    // InternalRoom.g:21501:1: rule__AnnotationType__Group_6_1__2 : rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3 ;
+    // InternalRoom.g:21730:1: rule__AnnotationType__Group_6_1__2 : rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3 ;
     public final void rule__AnnotationType__Group_6_1__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21505:1: ( rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3 )
-            // InternalRoom.g:21506:2: rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3
+            // InternalRoom.g:21734:1: ( rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3 )
+            // InternalRoom.g:21735:2: rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3
             {
-            pushFollow(FOLLOW_112);
+            pushFollow(FOLLOW_113);
             rule__AnnotationType__Group_6_1__2__Impl();
 
             state._fsp--;
@@ -58634,33 +59293,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__2__Impl"
-    // InternalRoom.g:21513:1: rule__AnnotationType__Group_6_1__2__Impl : ( ( rule__AnnotationType__Group_6_1_2__0 )* ) ;
+    // InternalRoom.g:21742:1: rule__AnnotationType__Group_6_1__2__Impl : ( ( rule__AnnotationType__Group_6_1_2__0 )* ) ;
     public final void rule__AnnotationType__Group_6_1__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21517:1: ( ( ( rule__AnnotationType__Group_6_1_2__0 )* ) )
-            // InternalRoom.g:21518:1: ( ( rule__AnnotationType__Group_6_1_2__0 )* )
+            // InternalRoom.g:21746:1: ( ( ( rule__AnnotationType__Group_6_1_2__0 )* ) )
+            // InternalRoom.g:21747:1: ( ( rule__AnnotationType__Group_6_1_2__0 )* )
             {
-            // InternalRoom.g:21518:1: ( ( rule__AnnotationType__Group_6_1_2__0 )* )
-            // InternalRoom.g:21519:1: ( rule__AnnotationType__Group_6_1_2__0 )*
+            // InternalRoom.g:21747:1: ( ( rule__AnnotationType__Group_6_1_2__0 )* )
+            // InternalRoom.g:21748:1: ( rule__AnnotationType__Group_6_1_2__0 )*
             {
              before(grammarAccess.getAnnotationTypeAccess().getGroup_6_1_2()); 
-            // InternalRoom.g:21520:1: ( rule__AnnotationType__Group_6_1_2__0 )*
-            loop197:
+            // InternalRoom.g:21749:1: ( rule__AnnotationType__Group_6_1_2__0 )*
+            loop200:
             do {
-                int alt197=2;
-                int LA197_0 = input.LA(1);
+                int alt200=2;
+                int LA200_0 = input.LA(1);
 
-                if ( (LA197_0==54) ) {
-                    alt197=1;
+                if ( (LA200_0==54) ) {
+                    alt200=1;
                 }
 
 
-                switch (alt197) {
+                switch (alt200) {
             	case 1 :
-            	    // InternalRoom.g:21520:2: rule__AnnotationType__Group_6_1_2__0
+            	    // InternalRoom.g:21749:2: rule__AnnotationType__Group_6_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__AnnotationType__Group_6_1_2__0();
@@ -58672,7 +59331,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop197;
+            	    break loop200;
                 }
             } while (true);
 
@@ -58699,14 +59358,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__3"
-    // InternalRoom.g:21530:1: rule__AnnotationType__Group_6_1__3 : rule__AnnotationType__Group_6_1__3__Impl ;
+    // InternalRoom.g:21759:1: rule__AnnotationType__Group_6_1__3 : rule__AnnotationType__Group_6_1__3__Impl ;
     public final void rule__AnnotationType__Group_6_1__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21534:1: ( rule__AnnotationType__Group_6_1__3__Impl )
-            // InternalRoom.g:21535:2: rule__AnnotationType__Group_6_1__3__Impl
+            // InternalRoom.g:21763:1: ( rule__AnnotationType__Group_6_1__3__Impl )
+            // InternalRoom.g:21764:2: rule__AnnotationType__Group_6_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group_6_1__3__Impl();
@@ -58732,17 +59391,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1__3__Impl"
-    // InternalRoom.g:21541:1: rule__AnnotationType__Group_6_1__3__Impl : ( '}' ) ;
+    // InternalRoom.g:21770:1: rule__AnnotationType__Group_6_1__3__Impl : ( '}' ) ;
     public final void rule__AnnotationType__Group_6_1__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21545:1: ( ( '}' ) )
-            // InternalRoom.g:21546:1: ( '}' )
+            // InternalRoom.g:21774:1: ( ( '}' ) )
+            // InternalRoom.g:21775:1: ( '}' )
             {
-            // InternalRoom.g:21546:1: ( '}' )
-            // InternalRoom.g:21547:1: '}'
+            // InternalRoom.g:21775:1: ( '}' )
+            // InternalRoom.g:21776:1: '}'
             {
              before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_6_1_3()); 
             match(input,45,FOLLOW_2); 
@@ -58769,16 +59428,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1_2__0"
-    // InternalRoom.g:21568:1: rule__AnnotationType__Group_6_1_2__0 : rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1 ;
+    // InternalRoom.g:21797:1: rule__AnnotationType__Group_6_1_2__0 : rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1 ;
     public final void rule__AnnotationType__Group_6_1_2__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21572:1: ( rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1 )
-            // InternalRoom.g:21573:2: rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1
+            // InternalRoom.g:21801:1: ( rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1 )
+            // InternalRoom.g:21802:2: rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1
             {
-            pushFollow(FOLLOW_111);
+            pushFollow(FOLLOW_112);
             rule__AnnotationType__Group_6_1_2__0__Impl();
 
             state._fsp--;
@@ -58807,17 +59466,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1_2__0__Impl"
-    // InternalRoom.g:21580:1: rule__AnnotationType__Group_6_1_2__0__Impl : ( ',' ) ;
+    // InternalRoom.g:21809:1: rule__AnnotationType__Group_6_1_2__0__Impl : ( ',' ) ;
     public final void rule__AnnotationType__Group_6_1_2__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21584:1: ( ( ',' ) )
-            // InternalRoom.g:21585:1: ( ',' )
+            // InternalRoom.g:21813:1: ( ( ',' ) )
+            // InternalRoom.g:21814:1: ( ',' )
             {
-            // InternalRoom.g:21585:1: ( ',' )
-            // InternalRoom.g:21586:1: ','
+            // InternalRoom.g:21814:1: ( ',' )
+            // InternalRoom.g:21815:1: ','
             {
              before(grammarAccess.getAnnotationTypeAccess().getCommaKeyword_6_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -58844,14 +59503,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1_2__1"
-    // InternalRoom.g:21599:1: rule__AnnotationType__Group_6_1_2__1 : rule__AnnotationType__Group_6_1_2__1__Impl ;
+    // InternalRoom.g:21828:1: rule__AnnotationType__Group_6_1_2__1 : rule__AnnotationType__Group_6_1_2__1__Impl ;
     public final void rule__AnnotationType__Group_6_1_2__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21603:1: ( rule__AnnotationType__Group_6_1_2__1__Impl )
-            // InternalRoom.g:21604:2: rule__AnnotationType__Group_6_1_2__1__Impl
+            // InternalRoom.g:21832:1: ( rule__AnnotationType__Group_6_1_2__1__Impl )
+            // InternalRoom.g:21833:2: rule__AnnotationType__Group_6_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group_6_1_2__1__Impl();
@@ -58877,21 +59536,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group_6_1_2__1__Impl"
-    // InternalRoom.g:21610:1: rule__AnnotationType__Group_6_1_2__1__Impl : ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) ) ;
+    // InternalRoom.g:21839:1: rule__AnnotationType__Group_6_1_2__1__Impl : ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) ) ;
     public final void rule__AnnotationType__Group_6_1_2__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21614:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) ) )
-            // InternalRoom.g:21615:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) )
+            // InternalRoom.g:21843:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) ) )
+            // InternalRoom.g:21844:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) )
             {
-            // InternalRoom.g:21615:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) )
-            // InternalRoom.g:21616:1: ( rule__AnnotationType__TargetsAssignment_6_1_2_1 )
+            // InternalRoom.g:21844:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) )
+            // InternalRoom.g:21845:1: ( rule__AnnotationType__TargetsAssignment_6_1_2_1 )
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_2_1()); 
-            // InternalRoom.g:21617:1: ( rule__AnnotationType__TargetsAssignment_6_1_2_1 )
-            // InternalRoom.g:21617:2: rule__AnnotationType__TargetsAssignment_6_1_2_1
+            // InternalRoom.g:21846:1: ( rule__AnnotationType__TargetsAssignment_6_1_2_1 )
+            // InternalRoom.g:21846:2: rule__AnnotationType__TargetsAssignment_6_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__TargetsAssignment_6_1_2_1();
@@ -58924,16 +59583,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0"
-    // InternalRoom.g:21631:1: rule__SimpleAnnotationAttribute__Group__0 : rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ;
+    // InternalRoom.g:21860:1: rule__SimpleAnnotationAttribute__Group__0 : rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ;
     public final void rule__SimpleAnnotationAttribute__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21635:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 )
-            // InternalRoom.g:21636:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1
+            // InternalRoom.g:21864:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 )
+            // InternalRoom.g:21865:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1
             {
-            pushFollow(FOLLOW_113);
+            pushFollow(FOLLOW_114);
             rule__SimpleAnnotationAttribute__Group__0__Impl();
 
             state._fsp--;
@@ -58962,21 +59621,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0__Impl"
-    // InternalRoom.g:21643:1: rule__SimpleAnnotationAttribute__Group__0__Impl : ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ;
+    // InternalRoom.g:21872:1: rule__SimpleAnnotationAttribute__Group__0__Impl : ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21647:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) )
-            // InternalRoom.g:21648:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:21876:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalRoom.g:21877:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalRoom.g:21648:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
-            // InternalRoom.g:21649:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21877:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:21878:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); 
-            // InternalRoom.g:21650:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
-            // InternalRoom.g:21650:2: rule__SimpleAnnotationAttribute__Alternatives_0
+            // InternalRoom.g:21879:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21879:2: rule__SimpleAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Alternatives_0();
@@ -59009,14 +59668,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1"
-    // InternalRoom.g:21660:1: rule__SimpleAnnotationAttribute__Group__1 : rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ;
+    // InternalRoom.g:21889:1: rule__SimpleAnnotationAttribute__Group__1 : rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ;
     public final void rule__SimpleAnnotationAttribute__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21664:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 )
-            // InternalRoom.g:21665:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2
+            // InternalRoom.g:21893:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 )
+            // InternalRoom.g:21894:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SimpleAnnotationAttribute__Group__1__Impl();
@@ -59047,17 +59706,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1__Impl"
-    // InternalRoom.g:21672:1: rule__SimpleAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
+    // InternalRoom.g:21901:1: rule__SimpleAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
     public final void rule__SimpleAnnotationAttribute__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21676:1: ( ( 'attribute' ) )
-            // InternalRoom.g:21677:1: ( 'attribute' )
+            // InternalRoom.g:21905:1: ( ( 'attribute' ) )
+            // InternalRoom.g:21906:1: ( 'attribute' )
             {
-            // InternalRoom.g:21677:1: ( 'attribute' )
-            // InternalRoom.g:21678:1: 'attribute'
+            // InternalRoom.g:21906:1: ( 'attribute' )
+            // InternalRoom.g:21907:1: 'attribute'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,124,FOLLOW_2); 
@@ -59084,14 +59743,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2"
-    // InternalRoom.g:21691:1: rule__SimpleAnnotationAttribute__Group__2 : rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ;
+    // InternalRoom.g:21920:1: rule__SimpleAnnotationAttribute__Group__2 : rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ;
     public final void rule__SimpleAnnotationAttribute__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21695:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 )
-            // InternalRoom.g:21696:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3
+            // InternalRoom.g:21924:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 )
+            // InternalRoom.g:21925:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__SimpleAnnotationAttribute__Group__2__Impl();
@@ -59122,21 +59781,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2__Impl"
-    // InternalRoom.g:21703:1: rule__SimpleAnnotationAttribute__Group__2__Impl : ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ;
+    // InternalRoom.g:21932:1: rule__SimpleAnnotationAttribute__Group__2__Impl : ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21707:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) )
-            // InternalRoom.g:21708:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:21936:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalRoom.g:21937:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalRoom.g:21708:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
-            // InternalRoom.g:21709:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21937:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:21938:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); 
-            // InternalRoom.g:21710:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
-            // InternalRoom.g:21710:2: rule__SimpleAnnotationAttribute__NameAssignment_2
+            // InternalRoom.g:21939:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21939:2: rule__SimpleAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__NameAssignment_2();
@@ -59169,14 +59828,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3"
-    // InternalRoom.g:21720:1: rule__SimpleAnnotationAttribute__Group__3 : rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ;
+    // InternalRoom.g:21949:1: rule__SimpleAnnotationAttribute__Group__3 : rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ;
     public final void rule__SimpleAnnotationAttribute__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21724:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 )
-            // InternalRoom.g:21725:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4
+            // InternalRoom.g:21953:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 )
+            // InternalRoom.g:21954:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_10);
             rule__SimpleAnnotationAttribute__Group__3__Impl();
@@ -59207,17 +59866,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3__Impl"
-    // InternalRoom.g:21732:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:21961:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ;
     public final void rule__SimpleAnnotationAttribute__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21736:1: ( ( ':' ) )
-            // InternalRoom.g:21737:1: ( ':' )
+            // InternalRoom.g:21965:1: ( ( ':' ) )
+            // InternalRoom.g:21966:1: ( ':' )
             {
-            // InternalRoom.g:21737:1: ( ':' )
-            // InternalRoom.g:21738:1: ':'
+            // InternalRoom.g:21966:1: ( ':' )
+            // InternalRoom.g:21967:1: ':'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -59244,14 +59903,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4"
-    // InternalRoom.g:21751:1: rule__SimpleAnnotationAttribute__Group__4 : rule__SimpleAnnotationAttribute__Group__4__Impl ;
+    // InternalRoom.g:21980:1: rule__SimpleAnnotationAttribute__Group__4 : rule__SimpleAnnotationAttribute__Group__4__Impl ;
     public final void rule__SimpleAnnotationAttribute__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21755:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl )
-            // InternalRoom.g:21756:2: rule__SimpleAnnotationAttribute__Group__4__Impl
+            // InternalRoom.g:21984:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl )
+            // InternalRoom.g:21985:2: rule__SimpleAnnotationAttribute__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__4__Impl();
@@ -59277,21 +59936,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4__Impl"
-    // InternalRoom.g:21762:1: rule__SimpleAnnotationAttribute__Group__4__Impl : ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ;
+    // InternalRoom.g:21991:1: rule__SimpleAnnotationAttribute__Group__4__Impl : ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ;
     public final void rule__SimpleAnnotationAttribute__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21766:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) )
-            // InternalRoom.g:21767:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
+            // InternalRoom.g:21995:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) )
+            // InternalRoom.g:21996:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
             {
-            // InternalRoom.g:21767:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
-            // InternalRoom.g:21768:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalRoom.g:21996:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
+            // InternalRoom.g:21997:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); 
-            // InternalRoom.g:21769:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
-            // InternalRoom.g:21769:2: rule__SimpleAnnotationAttribute__TypeAssignment_4
+            // InternalRoom.g:21998:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalRoom.g:21998:2: rule__SimpleAnnotationAttribute__TypeAssignment_4
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__TypeAssignment_4();
@@ -59324,16 +59983,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__0"
-    // InternalRoom.g:21789:1: rule__EnumAnnotationAttribute__Group__0 : rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ;
+    // InternalRoom.g:22018:1: rule__EnumAnnotationAttribute__Group__0 : rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ;
     public final void rule__EnumAnnotationAttribute__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21793:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 )
-            // InternalRoom.g:21794:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1
+            // InternalRoom.g:22022:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 )
+            // InternalRoom.g:22023:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1
             {
-            pushFollow(FOLLOW_113);
+            pushFollow(FOLLOW_114);
             rule__EnumAnnotationAttribute__Group__0__Impl();
 
             state._fsp--;
@@ -59362,21 +60021,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__0__Impl"
-    // InternalRoom.g:21801:1: rule__EnumAnnotationAttribute__Group__0__Impl : ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ;
+    // InternalRoom.g:22030:1: rule__EnumAnnotationAttribute__Group__0__Impl : ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21805:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) )
-            // InternalRoom.g:21806:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:22034:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalRoom.g:22035:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalRoom.g:21806:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
-            // InternalRoom.g:21807:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:22035:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:22036:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); 
-            // InternalRoom.g:21808:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
-            // InternalRoom.g:21808:2: rule__EnumAnnotationAttribute__Alternatives_0
+            // InternalRoom.g:22037:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:22037:2: rule__EnumAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Alternatives_0();
@@ -59409,14 +60068,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__1"
-    // InternalRoom.g:21818:1: rule__EnumAnnotationAttribute__Group__1 : rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ;
+    // InternalRoom.g:22047:1: rule__EnumAnnotationAttribute__Group__1 : rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ;
     public final void rule__EnumAnnotationAttribute__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21822:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 )
-            // InternalRoom.g:21823:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2
+            // InternalRoom.g:22051:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 )
+            // InternalRoom.g:22052:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__EnumAnnotationAttribute__Group__1__Impl();
@@ -59447,17 +60106,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__1__Impl"
-    // InternalRoom.g:21830:1: rule__EnumAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
+    // InternalRoom.g:22059:1: rule__EnumAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ;
     public final void rule__EnumAnnotationAttribute__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21834:1: ( ( 'attribute' ) )
-            // InternalRoom.g:21835:1: ( 'attribute' )
+            // InternalRoom.g:22063:1: ( ( 'attribute' ) )
+            // InternalRoom.g:22064:1: ( 'attribute' )
             {
-            // InternalRoom.g:21835:1: ( 'attribute' )
-            // InternalRoom.g:21836:1: 'attribute'
+            // InternalRoom.g:22064:1: ( 'attribute' )
+            // InternalRoom.g:22065:1: 'attribute'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,124,FOLLOW_2); 
@@ -59484,14 +60143,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__2"
-    // InternalRoom.g:21849:1: rule__EnumAnnotationAttribute__Group__2 : rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ;
+    // InternalRoom.g:22078:1: rule__EnumAnnotationAttribute__Group__2 : rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ;
     public final void rule__EnumAnnotationAttribute__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21853:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 )
-            // InternalRoom.g:21854:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3
+            // InternalRoom.g:22082:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 )
+            // InternalRoom.g:22083:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__EnumAnnotationAttribute__Group__2__Impl();
@@ -59522,21 +60181,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__2__Impl"
-    // InternalRoom.g:21861:1: rule__EnumAnnotationAttribute__Group__2__Impl : ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ;
+    // InternalRoom.g:22090:1: rule__EnumAnnotationAttribute__Group__2__Impl : ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21865:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) )
-            // InternalRoom.g:21866:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:22094:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalRoom.g:22095:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalRoom.g:21866:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
-            // InternalRoom.g:21867:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:22095:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:22096:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); 
-            // InternalRoom.g:21868:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
-            // InternalRoom.g:21868:2: rule__EnumAnnotationAttribute__NameAssignment_2
+            // InternalRoom.g:22097:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:22097:2: rule__EnumAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__NameAssignment_2();
@@ -59569,14 +60228,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__3"
-    // InternalRoom.g:21878:1: rule__EnumAnnotationAttribute__Group__3 : rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ;
+    // InternalRoom.g:22107:1: rule__EnumAnnotationAttribute__Group__3 : rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ;
     public final void rule__EnumAnnotationAttribute__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21882:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 )
-            // InternalRoom.g:21883:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4
+            // InternalRoom.g:22111:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 )
+            // InternalRoom.g:22112:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_40);
             rule__EnumAnnotationAttribute__Group__3__Impl();
@@ -59607,17 +60266,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__3__Impl"
-    // InternalRoom.g:21890:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:22119:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ;
     public final void rule__EnumAnnotationAttribute__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21894:1: ( ( ':' ) )
-            // InternalRoom.g:21895:1: ( ':' )
+            // InternalRoom.g:22123:1: ( ( ':' ) )
+            // InternalRoom.g:22124:1: ( ':' )
             {
-            // InternalRoom.g:21895:1: ( ':' )
-            // InternalRoom.g:21896:1: ':'
+            // InternalRoom.g:22124:1: ( ':' )
+            // InternalRoom.g:22125:1: ':'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -59644,14 +60303,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__4"
-    // InternalRoom.g:21909:1: rule__EnumAnnotationAttribute__Group__4 : rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ;
+    // InternalRoom.g:22138:1: rule__EnumAnnotationAttribute__Group__4 : rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ;
     public final void rule__EnumAnnotationAttribute__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21913:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 )
-            // InternalRoom.g:21914:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5
+            // InternalRoom.g:22142:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 )
+            // InternalRoom.g:22143:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5
             {
             pushFollow(FOLLOW_12);
             rule__EnumAnnotationAttribute__Group__4__Impl();
@@ -59682,17 +60341,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__4__Impl"
-    // InternalRoom.g:21921:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:22150:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ;
     public final void rule__EnumAnnotationAttribute__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21925:1: ( ( '{' ) )
-            // InternalRoom.g:21926:1: ( '{' )
+            // InternalRoom.g:22154:1: ( ( '{' ) )
+            // InternalRoom.g:22155:1: ( '{' )
             {
-            // InternalRoom.g:21926:1: ( '{' )
-            // InternalRoom.g:21927:1: '{'
+            // InternalRoom.g:22155:1: ( '{' )
+            // InternalRoom.g:22156:1: '{'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -59719,16 +60378,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__5"
-    // InternalRoom.g:21940:1: rule__EnumAnnotationAttribute__Group__5 : rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ;
+    // InternalRoom.g:22169:1: rule__EnumAnnotationAttribute__Group__5 : rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ;
     public final void rule__EnumAnnotationAttribute__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21944:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 )
-            // InternalRoom.g:21945:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6
+            // InternalRoom.g:22173:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 )
+            // InternalRoom.g:22174:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6
             {
-            pushFollow(FOLLOW_112);
+            pushFollow(FOLLOW_113);
             rule__EnumAnnotationAttribute__Group__5__Impl();
 
             state._fsp--;
@@ -59757,21 +60416,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__5__Impl"
-    // InternalRoom.g:21952:1: rule__EnumAnnotationAttribute__Group__5__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ;
+    // InternalRoom.g:22181:1: rule__EnumAnnotationAttribute__Group__5__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21956:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) )
-            // InternalRoom.g:21957:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
+            // InternalRoom.g:22185:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) )
+            // InternalRoom.g:22186:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
             {
-            // InternalRoom.g:21957:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
-            // InternalRoom.g:21958:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalRoom.g:22186:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
+            // InternalRoom.g:22187:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); 
-            // InternalRoom.g:21959:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
-            // InternalRoom.g:21959:2: rule__EnumAnnotationAttribute__ValuesAssignment_5
+            // InternalRoom.g:22188:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalRoom.g:22188:2: rule__EnumAnnotationAttribute__ValuesAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_5();
@@ -59804,16 +60463,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__6"
-    // InternalRoom.g:21969:1: rule__EnumAnnotationAttribute__Group__6 : rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ;
+    // InternalRoom.g:22198:1: rule__EnumAnnotationAttribute__Group__6 : rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ;
     public final void rule__EnumAnnotationAttribute__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21973:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 )
-            // InternalRoom.g:21974:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7
+            // InternalRoom.g:22202:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 )
+            // InternalRoom.g:22203:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7
             {
-            pushFollow(FOLLOW_112);
+            pushFollow(FOLLOW_113);
             rule__EnumAnnotationAttribute__Group__6__Impl();
 
             state._fsp--;
@@ -59842,33 +60501,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__6__Impl"
-    // InternalRoom.g:21981:1: rule__EnumAnnotationAttribute__Group__6__Impl : ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ;
+    // InternalRoom.g:22210:1: rule__EnumAnnotationAttribute__Group__6__Impl : ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ;
     public final void rule__EnumAnnotationAttribute__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:21985:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) )
-            // InternalRoom.g:21986:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
+            // InternalRoom.g:22214:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) )
+            // InternalRoom.g:22215:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
             {
-            // InternalRoom.g:21986:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
-            // InternalRoom.g:21987:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
+            // InternalRoom.g:22215:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
+            // InternalRoom.g:22216:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); 
-            // InternalRoom.g:21988:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
-            loop198:
+            // InternalRoom.g:22217:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
+            loop201:
             do {
-                int alt198=2;
-                int LA198_0 = input.LA(1);
+                int alt201=2;
+                int LA201_0 = input.LA(1);
 
-                if ( (LA198_0==54) ) {
-                    alt198=1;
+                if ( (LA201_0==54) ) {
+                    alt201=1;
                 }
 
 
-                switch (alt198) {
+                switch (alt201) {
             	case 1 :
-            	    // InternalRoom.g:21988:2: rule__EnumAnnotationAttribute__Group_6__0
+            	    // InternalRoom.g:22217:2: rule__EnumAnnotationAttribute__Group_6__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__EnumAnnotationAttribute__Group_6__0();
@@ -59880,7 +60539,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop198;
+            	    break loop201;
                 }
             } while (true);
 
@@ -59907,14 +60566,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__7"
-    // InternalRoom.g:21998:1: rule__EnumAnnotationAttribute__Group__7 : rule__EnumAnnotationAttribute__Group__7__Impl ;
+    // InternalRoom.g:22227:1: rule__EnumAnnotationAttribute__Group__7 : rule__EnumAnnotationAttribute__Group__7__Impl ;
     public final void rule__EnumAnnotationAttribute__Group__7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22002:1: ( rule__EnumAnnotationAttribute__Group__7__Impl )
-            // InternalRoom.g:22003:2: rule__EnumAnnotationAttribute__Group__7__Impl
+            // InternalRoom.g:22231:1: ( rule__EnumAnnotationAttribute__Group__7__Impl )
+            // InternalRoom.g:22232:2: rule__EnumAnnotationAttribute__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__7__Impl();
@@ -59940,17 +60599,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__7__Impl"
-    // InternalRoom.g:22009:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ;
+    // InternalRoom.g:22238:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ;
     public final void rule__EnumAnnotationAttribute__Group__7__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22013:1: ( ( '}' ) )
-            // InternalRoom.g:22014:1: ( '}' )
+            // InternalRoom.g:22242:1: ( ( '}' ) )
+            // InternalRoom.g:22243:1: ( '}' )
             {
-            // InternalRoom.g:22014:1: ( '}' )
-            // InternalRoom.g:22015:1: '}'
+            // InternalRoom.g:22243:1: ( '}' )
+            // InternalRoom.g:22244:1: '}'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); 
             match(input,45,FOLLOW_2); 
@@ -59977,14 +60636,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0"
-    // InternalRoom.g:22044:1: rule__EnumAnnotationAttribute__Group_6__0 : rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ;
+    // InternalRoom.g:22273:1: rule__EnumAnnotationAttribute__Group_6__0 : rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ;
     public final void rule__EnumAnnotationAttribute__Group_6__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22048:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 )
-            // InternalRoom.g:22049:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1
+            // InternalRoom.g:22277:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 )
+            // InternalRoom.g:22278:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1
             {
             pushFollow(FOLLOW_12);
             rule__EnumAnnotationAttribute__Group_6__0__Impl();
@@ -60015,17 +60674,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0__Impl"
-    // InternalRoom.g:22056:1: rule__EnumAnnotationAttribute__Group_6__0__Impl : ( ',' ) ;
+    // InternalRoom.g:22285:1: rule__EnumAnnotationAttribute__Group_6__0__Impl : ( ',' ) ;
     public final void rule__EnumAnnotationAttribute__Group_6__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22060:1: ( ( ',' ) )
-            // InternalRoom.g:22061:1: ( ',' )
+            // InternalRoom.g:22289:1: ( ( ',' ) )
+            // InternalRoom.g:22290:1: ( ',' )
             {
-            // InternalRoom.g:22061:1: ( ',' )
-            // InternalRoom.g:22062:1: ','
+            // InternalRoom.g:22290:1: ( ',' )
+            // InternalRoom.g:22291:1: ','
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); 
             match(input,54,FOLLOW_2); 
@@ -60052,14 +60711,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1"
-    // InternalRoom.g:22075:1: rule__EnumAnnotationAttribute__Group_6__1 : rule__EnumAnnotationAttribute__Group_6__1__Impl ;
+    // InternalRoom.g:22304:1: rule__EnumAnnotationAttribute__Group_6__1 : rule__EnumAnnotationAttribute__Group_6__1__Impl ;
     public final void rule__EnumAnnotationAttribute__Group_6__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22079:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl )
-            // InternalRoom.g:22080:2: rule__EnumAnnotationAttribute__Group_6__1__Impl
+            // InternalRoom.g:22308:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl )
+            // InternalRoom.g:22309:2: rule__EnumAnnotationAttribute__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group_6__1__Impl();
@@ -60085,21 +60744,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1__Impl"
-    // InternalRoom.g:22086:1: rule__EnumAnnotationAttribute__Group_6__1__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ;
+    // InternalRoom.g:22315:1: rule__EnumAnnotationAttribute__Group_6__1__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ;
     public final void rule__EnumAnnotationAttribute__Group_6__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22090:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) )
-            // InternalRoom.g:22091:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
+            // InternalRoom.g:22319:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) )
+            // InternalRoom.g:22320:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
             {
-            // InternalRoom.g:22091:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
-            // InternalRoom.g:22092:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
+            // InternalRoom.g:22320:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
+            // InternalRoom.g:22321:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); 
-            // InternalRoom.g:22093:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
-            // InternalRoom.g:22093:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1
+            // InternalRoom.g:22322:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
+            // InternalRoom.g:22322:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_6_1();
@@ -60132,16 +60791,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__0"
-    // InternalRoom.g:22107:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ;
+    // InternalRoom.g:22336:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ;
     public final void rule__Import__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22111:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 )
-            // InternalRoom.g:22112:2: rule__Import__Group__0__Impl rule__Import__Group__1
+            // InternalRoom.g:22340:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 )
+            // InternalRoom.g:22341:2: rule__Import__Group__0__Impl rule__Import__Group__1
             {
-            pushFollow(FOLLOW_114);
+            pushFollow(FOLLOW_115);
             rule__Import__Group__0__Impl();
 
             state._fsp--;
@@ -60170,17 +60829,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__0__Impl"
-    // InternalRoom.g:22119:1: rule__Import__Group__0__Impl : ( 'import' ) ;
+    // InternalRoom.g:22348:1: rule__Import__Group__0__Impl : ( 'import' ) ;
     public final void rule__Import__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22123:1: ( ( 'import' ) )
-            // InternalRoom.g:22124:1: ( 'import' )
+            // InternalRoom.g:22352:1: ( ( 'import' ) )
+            // InternalRoom.g:22353:1: ( 'import' )
             {
-            // InternalRoom.g:22124:1: ( 'import' )
-            // InternalRoom.g:22125:1: 'import'
+            // InternalRoom.g:22353:1: ( 'import' )
+            // InternalRoom.g:22354:1: 'import'
             {
              before(grammarAccess.getImportAccess().getImportKeyword_0()); 
             match(input,125,FOLLOW_2); 
@@ -60207,14 +60866,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__1"
-    // InternalRoom.g:22138:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ;
+    // InternalRoom.g:22367:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ;
     public final void rule__Import__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22142:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 )
-            // InternalRoom.g:22143:2: rule__Import__Group__1__Impl rule__Import__Group__2
+            // InternalRoom.g:22371:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 )
+            // InternalRoom.g:22372:2: rule__Import__Group__1__Impl rule__Import__Group__2
             {
             pushFollow(FOLLOW_12);
             rule__Import__Group__1__Impl();
@@ -60245,21 +60904,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__1__Impl"
-    // InternalRoom.g:22150:1: rule__Import__Group__1__Impl : ( ( rule__Import__Alternatives_1 ) ) ;
+    // InternalRoom.g:22379:1: rule__Import__Group__1__Impl : ( ( rule__Import__Alternatives_1 ) ) ;
     public final void rule__Import__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22154:1: ( ( ( rule__Import__Alternatives_1 ) ) )
-            // InternalRoom.g:22155:1: ( ( rule__Import__Alternatives_1 ) )
+            // InternalRoom.g:22383:1: ( ( ( rule__Import__Alternatives_1 ) ) )
+            // InternalRoom.g:22384:1: ( ( rule__Import__Alternatives_1 ) )
             {
-            // InternalRoom.g:22155:1: ( ( rule__Import__Alternatives_1 ) )
-            // InternalRoom.g:22156:1: ( rule__Import__Alternatives_1 )
+            // InternalRoom.g:22384:1: ( ( rule__Import__Alternatives_1 ) )
+            // InternalRoom.g:22385:1: ( rule__Import__Alternatives_1 )
             {
              before(grammarAccess.getImportAccess().getAlternatives_1()); 
-            // InternalRoom.g:22157:1: ( rule__Import__Alternatives_1 )
-            // InternalRoom.g:22157:2: rule__Import__Alternatives_1
+            // InternalRoom.g:22386:1: ( rule__Import__Alternatives_1 )
+            // InternalRoom.g:22386:2: rule__Import__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__Import__Alternatives_1();
@@ -60292,14 +60951,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__2"
-    // InternalRoom.g:22167:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ;
+    // InternalRoom.g:22396:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ;
     public final void rule__Import__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22171:1: ( rule__Import__Group__2__Impl )
-            // InternalRoom.g:22172:2: rule__Import__Group__2__Impl
+            // InternalRoom.g:22400:1: ( rule__Import__Group__2__Impl )
+            // InternalRoom.g:22401:2: rule__Import__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group__2__Impl();
@@ -60325,21 +60984,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group__2__Impl"
-    // InternalRoom.g:22178:1: rule__Import__Group__2__Impl : ( ( rule__Import__ImportURIAssignment_2 ) ) ;
+    // InternalRoom.g:22407:1: rule__Import__Group__2__Impl : ( ( rule__Import__ImportURIAssignment_2 ) ) ;
     public final void rule__Import__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22182:1: ( ( ( rule__Import__ImportURIAssignment_2 ) ) )
-            // InternalRoom.g:22183:1: ( ( rule__Import__ImportURIAssignment_2 ) )
+            // InternalRoom.g:22411:1: ( ( ( rule__Import__ImportURIAssignment_2 ) ) )
+            // InternalRoom.g:22412:1: ( ( rule__Import__ImportURIAssignment_2 ) )
             {
-            // InternalRoom.g:22183:1: ( ( rule__Import__ImportURIAssignment_2 ) )
-            // InternalRoom.g:22184:1: ( rule__Import__ImportURIAssignment_2 )
+            // InternalRoom.g:22412:1: ( ( rule__Import__ImportURIAssignment_2 ) )
+            // InternalRoom.g:22413:1: ( rule__Import__ImportURIAssignment_2 )
             {
              before(grammarAccess.getImportAccess().getImportURIAssignment_2()); 
-            // InternalRoom.g:22185:1: ( rule__Import__ImportURIAssignment_2 )
-            // InternalRoom.g:22185:2: rule__Import__ImportURIAssignment_2
+            // InternalRoom.g:22414:1: ( rule__Import__ImportURIAssignment_2 )
+            // InternalRoom.g:22414:2: rule__Import__ImportURIAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Import__ImportURIAssignment_2();
@@ -60372,16 +61031,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group_1_0__0"
-    // InternalRoom.g:22201:1: rule__Import__Group_1_0__0 : rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1 ;
+    // InternalRoom.g:22430:1: rule__Import__Group_1_0__0 : rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1 ;
     public final void rule__Import__Group_1_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22205:1: ( rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1 )
-            // InternalRoom.g:22206:2: rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1
+            // InternalRoom.g:22434:1: ( rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1 )
+            // InternalRoom.g:22435:2: rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1
             {
-            pushFollow(FOLLOW_115);
+            pushFollow(FOLLOW_116);
             rule__Import__Group_1_0__0__Impl();
 
             state._fsp--;
@@ -60410,21 +61069,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group_1_0__0__Impl"
-    // InternalRoom.g:22213:1: rule__Import__Group_1_0__0__Impl : ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) ) ;
+    // InternalRoom.g:22442:1: rule__Import__Group_1_0__0__Impl : ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) ) ;
     public final void rule__Import__Group_1_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22217:1: ( ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) ) )
-            // InternalRoom.g:22218:1: ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) )
+            // InternalRoom.g:22446:1: ( ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) ) )
+            // InternalRoom.g:22447:1: ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) )
             {
-            // InternalRoom.g:22218:1: ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) )
-            // InternalRoom.g:22219:1: ( rule__Import__ImportedNamespaceAssignment_1_0_0 )
+            // InternalRoom.g:22447:1: ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) )
+            // InternalRoom.g:22448:1: ( rule__Import__ImportedNamespaceAssignment_1_0_0 )
             {
              before(grammarAccess.getImportAccess().getImportedNamespaceAssignment_1_0_0()); 
-            // InternalRoom.g:22220:1: ( rule__Import__ImportedNamespaceAssignment_1_0_0 )
-            // InternalRoom.g:22220:2: rule__Import__ImportedNamespaceAssignment_1_0_0
+            // InternalRoom.g:22449:1: ( rule__Import__ImportedNamespaceAssignment_1_0_0 )
+            // InternalRoom.g:22449:2: rule__Import__ImportedNamespaceAssignment_1_0_0
             {
             pushFollow(FOLLOW_2);
             rule__Import__ImportedNamespaceAssignment_1_0_0();
@@ -60457,14 +61116,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group_1_0__1"
-    // InternalRoom.g:22230:1: rule__Import__Group_1_0__1 : rule__Import__Group_1_0__1__Impl ;
+    // InternalRoom.g:22459:1: rule__Import__Group_1_0__1 : rule__Import__Group_1_0__1__Impl ;
     public final void rule__Import__Group_1_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22234:1: ( rule__Import__Group_1_0__1__Impl )
-            // InternalRoom.g:22235:2: rule__Import__Group_1_0__1__Impl
+            // InternalRoom.g:22463:1: ( rule__Import__Group_1_0__1__Impl )
+            // InternalRoom.g:22464:2: rule__Import__Group_1_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group_1_0__1__Impl();
@@ -60490,17 +61149,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__Group_1_0__1__Impl"
-    // InternalRoom.g:22241:1: rule__Import__Group_1_0__1__Impl : ( 'from' ) ;
+    // InternalRoom.g:22470:1: rule__Import__Group_1_0__1__Impl : ( 'from' ) ;
     public final void rule__Import__Group_1_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22245:1: ( ( 'from' ) )
-            // InternalRoom.g:22246:1: ( 'from' )
+            // InternalRoom.g:22474:1: ( ( 'from' ) )
+            // InternalRoom.g:22475:1: ( 'from' )
             {
-            // InternalRoom.g:22246:1: ( 'from' )
-            // InternalRoom.g:22247:1: 'from'
+            // InternalRoom.g:22475:1: ( 'from' )
+            // InternalRoom.g:22476:1: 'from'
             {
              before(grammarAccess.getImportAccess().getFromKeyword_1_0_1()); 
             match(input,126,FOLLOW_2); 
@@ -60527,16 +61186,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__0"
-    // InternalRoom.g:22264:1: rule__ImportedFQN__Group__0 : rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ;
+    // InternalRoom.g:22493:1: rule__ImportedFQN__Group__0 : rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ;
     public final void rule__ImportedFQN__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22268:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 )
-            // InternalRoom.g:22269:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1
+            // InternalRoom.g:22497:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 )
+            // InternalRoom.g:22498:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1
             {
-            pushFollow(FOLLOW_116);
+            pushFollow(FOLLOW_117);
             rule__ImportedFQN__Group__0__Impl();
 
             state._fsp--;
@@ -60565,17 +61224,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__0__Impl"
-    // InternalRoom.g:22276:1: rule__ImportedFQN__Group__0__Impl : ( ruleFQN ) ;
+    // InternalRoom.g:22505:1: rule__ImportedFQN__Group__0__Impl : ( ruleFQN ) ;
     public final void rule__ImportedFQN__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22280:1: ( ( ruleFQN ) )
-            // InternalRoom.g:22281:1: ( ruleFQN )
+            // InternalRoom.g:22509:1: ( ( ruleFQN ) )
+            // InternalRoom.g:22510:1: ( ruleFQN )
             {
-            // InternalRoom.g:22281:1: ( ruleFQN )
-            // InternalRoom.g:22282:1: ruleFQN
+            // InternalRoom.g:22510:1: ( ruleFQN )
+            // InternalRoom.g:22511:1: ruleFQN
             {
              before(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
             pushFollow(FOLLOW_2);
@@ -60606,14 +61265,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__1"
-    // InternalRoom.g:22293:1: rule__ImportedFQN__Group__1 : rule__ImportedFQN__Group__1__Impl ;
+    // InternalRoom.g:22522:1: rule__ImportedFQN__Group__1 : rule__ImportedFQN__Group__1__Impl ;
     public final void rule__ImportedFQN__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22297:1: ( rule__ImportedFQN__Group__1__Impl )
-            // InternalRoom.g:22298:2: rule__ImportedFQN__Group__1__Impl
+            // InternalRoom.g:22526:1: ( rule__ImportedFQN__Group__1__Impl )
+            // InternalRoom.g:22527:2: rule__ImportedFQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__1__Impl();
@@ -60639,29 +61298,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__1__Impl"
-    // InternalRoom.g:22304:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ;
+    // InternalRoom.g:22533:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ;
     public final void rule__ImportedFQN__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22308:1: ( ( ( '.*' )? ) )
-            // InternalRoom.g:22309:1: ( ( '.*' )? )
+            // InternalRoom.g:22537:1: ( ( ( '.*' )? ) )
+            // InternalRoom.g:22538:1: ( ( '.*' )? )
             {
-            // InternalRoom.g:22309:1: ( ( '.*' )? )
-            // InternalRoom.g:22310:1: ( '.*' )?
+            // InternalRoom.g:22538:1: ( ( '.*' )? )
+            // InternalRoom.g:22539:1: ( '.*' )?
             {
              before(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); 
-            // InternalRoom.g:22311:1: ( '.*' )?
-            int alt199=2;
-            int LA199_0 = input.LA(1);
+            // InternalRoom.g:22540:1: ( '.*' )?
+            int alt202=2;
+            int LA202_0 = input.LA(1);
 
-            if ( (LA199_0==127) ) {
-                alt199=1;
+            if ( (LA202_0==127) ) {
+                alt202=1;
             }
-            switch (alt199) {
+            switch (alt202) {
                 case 1 :
-                    // InternalRoom.g:22312:2: '.*'
+                    // InternalRoom.g:22541:2: '.*'
                     {
                     match(input,127,FOLLOW_2); 
 
@@ -60693,14 +61352,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__0"
-    // InternalRoom.g:22327:1: rule__Documentation__Group__0 : rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ;
+    // InternalRoom.g:22556:1: rule__Documentation__Group__0 : rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ;
     public final void rule__Documentation__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22331:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 )
-            // InternalRoom.g:22332:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1
+            // InternalRoom.g:22560:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 )
+            // InternalRoom.g:22561:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1
             {
             pushFollow(FOLLOW_14);
             rule__Documentation__Group__0__Impl();
@@ -60731,21 +61390,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__0__Impl"
-    // InternalRoom.g:22339:1: rule__Documentation__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22568:1: rule__Documentation__Group__0__Impl : ( () ) ;
     public final void rule__Documentation__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22343:1: ( ( () ) )
-            // InternalRoom.g:22344:1: ( () )
+            // InternalRoom.g:22572:1: ( ( () ) )
+            // InternalRoom.g:22573:1: ( () )
             {
-            // InternalRoom.g:22344:1: ( () )
-            // InternalRoom.g:22345:1: ()
+            // InternalRoom.g:22573:1: ( () )
+            // InternalRoom.g:22574:1: ()
             {
              before(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); 
-            // InternalRoom.g:22346:1: ()
-            // InternalRoom.g:22348:1: 
+            // InternalRoom.g:22575:1: ()
+            // InternalRoom.g:22577:1: 
             {
             }
 
@@ -60768,16 +61427,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__1"
-    // InternalRoom.g:22358:1: rule__Documentation__Group__1 : rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ;
+    // InternalRoom.g:22587:1: rule__Documentation__Group__1 : rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ;
     public final void rule__Documentation__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22362:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 )
-            // InternalRoom.g:22363:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2
+            // InternalRoom.g:22591:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 )
+            // InternalRoom.g:22592:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2
             {
-            pushFollow(FOLLOW_117);
+            pushFollow(FOLLOW_118);
             rule__Documentation__Group__1__Impl();
 
             state._fsp--;
@@ -60806,17 +61465,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__1__Impl"
-    // InternalRoom.g:22370:1: rule__Documentation__Group__1__Impl : ( '[' ) ;
+    // InternalRoom.g:22599:1: rule__Documentation__Group__1__Impl : ( '[' ) ;
     public final void rule__Documentation__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22374:1: ( ( '[' ) )
-            // InternalRoom.g:22375:1: ( '[' )
+            // InternalRoom.g:22603:1: ( ( '[' ) )
+            // InternalRoom.g:22604:1: ( '[' )
             {
-            // InternalRoom.g:22375:1: ( '[' )
-            // InternalRoom.g:22376:1: '['
+            // InternalRoom.g:22604:1: ( '[' )
+            // InternalRoom.g:22605:1: '['
             {
              before(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); 
             match(input,62,FOLLOW_2); 
@@ -60843,16 +61502,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__2"
-    // InternalRoom.g:22389:1: rule__Documentation__Group__2 : rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ;
+    // InternalRoom.g:22618:1: rule__Documentation__Group__2 : rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ;
     public final void rule__Documentation__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22393:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 )
-            // InternalRoom.g:22394:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3
+            // InternalRoom.g:22622:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 )
+            // InternalRoom.g:22623:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3
             {
-            pushFollow(FOLLOW_117);
+            pushFollow(FOLLOW_118);
             rule__Documentation__Group__2__Impl();
 
             state._fsp--;
@@ -60881,35 +61540,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__2__Impl"
-    // InternalRoom.g:22401:1: rule__Documentation__Group__2__Impl : ( ( rule__Documentation__LinesAssignment_2 )* ) ;
+    // InternalRoom.g:22630:1: rule__Documentation__Group__2__Impl : ( ( rule__Documentation__LinesAssignment_2 )* ) ;
     public final void rule__Documentation__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22405:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) )
-            // InternalRoom.g:22406:1: ( ( rule__Documentation__LinesAssignment_2 )* )
+            // InternalRoom.g:22634:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) )
+            // InternalRoom.g:22635:1: ( ( rule__Documentation__LinesAssignment_2 )* )
             {
-            // InternalRoom.g:22406:1: ( ( rule__Documentation__LinesAssignment_2 )* )
-            // InternalRoom.g:22407:1: ( rule__Documentation__LinesAssignment_2 )*
+            // InternalRoom.g:22635:1: ( ( rule__Documentation__LinesAssignment_2 )* )
+            // InternalRoom.g:22636:1: ( rule__Documentation__LinesAssignment_2 )*
             {
              before(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); 
-            // InternalRoom.g:22408:1: ( rule__Documentation__LinesAssignment_2 )*
-            loop200:
+            // InternalRoom.g:22637:1: ( rule__Documentation__LinesAssignment_2 )*
+            loop203:
             do {
-                int alt200=2;
-                int LA200_0 = input.LA(1);
+                int alt203=2;
+                int LA203_0 = input.LA(1);
 
-                if ( (LA200_0==RULE_STRING) ) {
-                    alt200=1;
+                if ( (LA203_0==RULE_STRING) ) {
+                    alt203=1;
                 }
 
 
-                switch (alt200) {
+                switch (alt203) {
             	case 1 :
-            	    // InternalRoom.g:22408:2: rule__Documentation__LinesAssignment_2
+            	    // InternalRoom.g:22637:2: rule__Documentation__LinesAssignment_2
             	    {
-            	    pushFollow(FOLLOW_84);
+            	    pushFollow(FOLLOW_85);
             	    rule__Documentation__LinesAssignment_2();
 
             	    state._fsp--;
@@ -60919,7 +61578,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop200;
+            	    break loop203;
                 }
             } while (true);
 
@@ -60946,14 +61605,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__3"
-    // InternalRoom.g:22418:1: rule__Documentation__Group__3 : rule__Documentation__Group__3__Impl ;
+    // InternalRoom.g:22647:1: rule__Documentation__Group__3 : rule__Documentation__Group__3__Impl ;
     public final void rule__Documentation__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22422:1: ( rule__Documentation__Group__3__Impl )
-            // InternalRoom.g:22423:2: rule__Documentation__Group__3__Impl
+            // InternalRoom.g:22651:1: ( rule__Documentation__Group__3__Impl )
+            // InternalRoom.g:22652:2: rule__Documentation__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__3__Impl();
@@ -60979,17 +61638,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__3__Impl"
-    // InternalRoom.g:22429:1: rule__Documentation__Group__3__Impl : ( ']' ) ;
+    // InternalRoom.g:22658:1: rule__Documentation__Group__3__Impl : ( ']' ) ;
     public final void rule__Documentation__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22433:1: ( ( ']' ) )
-            // InternalRoom.g:22434:1: ( ']' )
+            // InternalRoom.g:22662:1: ( ( ']' ) )
+            // InternalRoom.g:22663:1: ( ']' )
             {
-            // InternalRoom.g:22434:1: ( ']' )
-            // InternalRoom.g:22435:1: ']'
+            // InternalRoom.g:22663:1: ( ']' )
+            // InternalRoom.g:22664:1: ']'
             {
              before(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); 
             match(input,63,FOLLOW_2); 
@@ -61016,16 +61675,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__0"
-    // InternalRoom.g:22462:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ;
+    // InternalRoom.g:22691:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ;
     public final void rule__BooleanLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22466:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 )
-            // InternalRoom.g:22467:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1
+            // InternalRoom.g:22695:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 )
+            // InternalRoom.g:22696:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1
             {
-            pushFollow(FOLLOW_118);
+            pushFollow(FOLLOW_119);
             rule__BooleanLiteral__Group__0__Impl();
 
             state._fsp--;
@@ -61054,21 +61713,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__0__Impl"
-    // InternalRoom.g:22474:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22703:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ;
     public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22478:1: ( ( () ) )
-            // InternalRoom.g:22479:1: ( () )
+            // InternalRoom.g:22707:1: ( ( () ) )
+            // InternalRoom.g:22708:1: ( () )
             {
-            // InternalRoom.g:22479:1: ( () )
-            // InternalRoom.g:22480:1: ()
+            // InternalRoom.g:22708:1: ( () )
+            // InternalRoom.g:22709:1: ()
             {
              before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); 
-            // InternalRoom.g:22481:1: ()
-            // InternalRoom.g:22483:1: 
+            // InternalRoom.g:22710:1: ()
+            // InternalRoom.g:22712:1: 
             {
             }
 
@@ -61091,14 +61750,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__1"
-    // InternalRoom.g:22493:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ;
+    // InternalRoom.g:22722:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ;
     public final void rule__BooleanLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22497:1: ( rule__BooleanLiteral__Group__1__Impl )
-            // InternalRoom.g:22498:2: rule__BooleanLiteral__Group__1__Impl
+            // InternalRoom.g:22726:1: ( rule__BooleanLiteral__Group__1__Impl )
+            // InternalRoom.g:22727:2: rule__BooleanLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__1__Impl();
@@ -61124,21 +61783,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__1__Impl"
-    // InternalRoom.g:22504:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ;
+    // InternalRoom.g:22733:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ;
     public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22508:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) )
-            // InternalRoom.g:22509:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
+            // InternalRoom.g:22737:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) )
+            // InternalRoom.g:22738:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
             {
-            // InternalRoom.g:22509:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
-            // InternalRoom.g:22510:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalRoom.g:22738:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
+            // InternalRoom.g:22739:1: ( rule__BooleanLiteral__Alternatives_1 )
             {
              before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); 
-            // InternalRoom.g:22511:1: ( rule__BooleanLiteral__Alternatives_1 )
-            // InternalRoom.g:22511:2: rule__BooleanLiteral__Alternatives_1
+            // InternalRoom.g:22740:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalRoom.g:22740:2: rule__BooleanLiteral__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Alternatives_1();
@@ -61171,14 +61830,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__0"
-    // InternalRoom.g:22525:1: rule__RealLiteral__Group__0 : rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ;
+    // InternalRoom.g:22754:1: rule__RealLiteral__Group__0 : rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ;
     public final void rule__RealLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22529:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 )
-            // InternalRoom.g:22530:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1
+            // InternalRoom.g:22758:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 )
+            // InternalRoom.g:22759:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__RealLiteral__Group__0__Impl();
@@ -61209,21 +61868,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__0__Impl"
-    // InternalRoom.g:22537:1: rule__RealLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22766:1: rule__RealLiteral__Group__0__Impl : ( () ) ;
     public final void rule__RealLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22541:1: ( ( () ) )
-            // InternalRoom.g:22542:1: ( () )
+            // InternalRoom.g:22770:1: ( ( () ) )
+            // InternalRoom.g:22771:1: ( () )
             {
-            // InternalRoom.g:22542:1: ( () )
-            // InternalRoom.g:22543:1: ()
+            // InternalRoom.g:22771:1: ( () )
+            // InternalRoom.g:22772:1: ()
             {
              before(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); 
-            // InternalRoom.g:22544:1: ()
-            // InternalRoom.g:22546:1: 
+            // InternalRoom.g:22773:1: ()
+            // InternalRoom.g:22775:1: 
             {
             }
 
@@ -61246,14 +61905,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__1"
-    // InternalRoom.g:22556:1: rule__RealLiteral__Group__1 : rule__RealLiteral__Group__1__Impl ;
+    // InternalRoom.g:22785:1: rule__RealLiteral__Group__1 : rule__RealLiteral__Group__1__Impl ;
     public final void rule__RealLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22560:1: ( rule__RealLiteral__Group__1__Impl )
-            // InternalRoom.g:22561:2: rule__RealLiteral__Group__1__Impl
+            // InternalRoom.g:22789:1: ( rule__RealLiteral__Group__1__Impl )
+            // InternalRoom.g:22790:2: rule__RealLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__1__Impl();
@@ -61279,21 +61938,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__1__Impl"
-    // InternalRoom.g:22567:1: rule__RealLiteral__Group__1__Impl : ( ( rule__RealLiteral__ValueAssignment_1 ) ) ;
+    // InternalRoom.g:22796:1: rule__RealLiteral__Group__1__Impl : ( ( rule__RealLiteral__ValueAssignment_1 ) ) ;
     public final void rule__RealLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22571:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) )
-            // InternalRoom.g:22572:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22800:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22801:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22572:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22573:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22801:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22802:1: ( rule__RealLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); 
-            // InternalRoom.g:22574:1: ( rule__RealLiteral__ValueAssignment_1 )
-            // InternalRoom.g:22574:2: rule__RealLiteral__ValueAssignment_1
+            // InternalRoom.g:22803:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22803:2: rule__RealLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__ValueAssignment_1();
@@ -61326,14 +61985,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__0"
-    // InternalRoom.g:22588:1: rule__IntLiteral__Group__0 : rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ;
+    // InternalRoom.g:22817:1: rule__IntLiteral__Group__0 : rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ;
     public final void rule__IntLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22592:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 )
-            // InternalRoom.g:22593:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1
+            // InternalRoom.g:22821:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 )
+            // InternalRoom.g:22822:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__IntLiteral__Group__0__Impl();
@@ -61364,21 +62023,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__0__Impl"
-    // InternalRoom.g:22600:1: rule__IntLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22829:1: rule__IntLiteral__Group__0__Impl : ( () ) ;
     public final void rule__IntLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22604:1: ( ( () ) )
-            // InternalRoom.g:22605:1: ( () )
+            // InternalRoom.g:22833:1: ( ( () ) )
+            // InternalRoom.g:22834:1: ( () )
             {
-            // InternalRoom.g:22605:1: ( () )
-            // InternalRoom.g:22606:1: ()
+            // InternalRoom.g:22834:1: ( () )
+            // InternalRoom.g:22835:1: ()
             {
              before(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); 
-            // InternalRoom.g:22607:1: ()
-            // InternalRoom.g:22609:1: 
+            // InternalRoom.g:22836:1: ()
+            // InternalRoom.g:22838:1: 
             {
             }
 
@@ -61401,14 +62060,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__1"
-    // InternalRoom.g:22619:1: rule__IntLiteral__Group__1 : rule__IntLiteral__Group__1__Impl ;
+    // InternalRoom.g:22848:1: rule__IntLiteral__Group__1 : rule__IntLiteral__Group__1__Impl ;
     public final void rule__IntLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22623:1: ( rule__IntLiteral__Group__1__Impl )
-            // InternalRoom.g:22624:2: rule__IntLiteral__Group__1__Impl
+            // InternalRoom.g:22852:1: ( rule__IntLiteral__Group__1__Impl )
+            // InternalRoom.g:22853:2: rule__IntLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__1__Impl();
@@ -61434,21 +62093,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__1__Impl"
-    // InternalRoom.g:22630:1: rule__IntLiteral__Group__1__Impl : ( ( rule__IntLiteral__ValueAssignment_1 ) ) ;
+    // InternalRoom.g:22859:1: rule__IntLiteral__Group__1__Impl : ( ( rule__IntLiteral__ValueAssignment_1 ) ) ;
     public final void rule__IntLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22634:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) )
-            // InternalRoom.g:22635:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22863:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22864:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22635:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22636:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22864:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22865:1: ( rule__IntLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); 
-            // InternalRoom.g:22637:1: ( rule__IntLiteral__ValueAssignment_1 )
-            // InternalRoom.g:22637:2: rule__IntLiteral__ValueAssignment_1
+            // InternalRoom.g:22866:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22866:2: rule__IntLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__ValueAssignment_1();
@@ -61481,16 +62140,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__0"
-    // InternalRoom.g:22651:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ;
+    // InternalRoom.g:22880:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ;
     public final void rule__StringLiteral__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22655:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
-            // InternalRoom.g:22656:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
+            // InternalRoom.g:22884:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
+            // InternalRoom.g:22885:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
             {
-            pushFollow(FOLLOW_106);
+            pushFollow(FOLLOW_107);
             rule__StringLiteral__Group__0__Impl();
 
             state._fsp--;
@@ -61519,21 +62178,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__0__Impl"
-    // InternalRoom.g:22663:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22892:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
     public final void rule__StringLiteral__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22667:1: ( ( () ) )
-            // InternalRoom.g:22668:1: ( () )
+            // InternalRoom.g:22896:1: ( ( () ) )
+            // InternalRoom.g:22897:1: ( () )
             {
-            // InternalRoom.g:22668:1: ( () )
-            // InternalRoom.g:22669:1: ()
+            // InternalRoom.g:22897:1: ( () )
+            // InternalRoom.g:22898:1: ()
             {
              before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); 
-            // InternalRoom.g:22670:1: ()
-            // InternalRoom.g:22672:1: 
+            // InternalRoom.g:22899:1: ()
+            // InternalRoom.g:22901:1: 
             {
             }
 
@@ -61556,14 +62215,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__1"
-    // InternalRoom.g:22682:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ;
+    // InternalRoom.g:22911:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ;
     public final void rule__StringLiteral__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22686:1: ( rule__StringLiteral__Group__1__Impl )
-            // InternalRoom.g:22687:2: rule__StringLiteral__Group__1__Impl
+            // InternalRoom.g:22915:1: ( rule__StringLiteral__Group__1__Impl )
+            // InternalRoom.g:22916:2: rule__StringLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__1__Impl();
@@ -61589,21 +62248,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__1__Impl"
-    // InternalRoom.g:22693:1: rule__StringLiteral__Group__1__Impl : ( ( rule__StringLiteral__ValueAssignment_1 ) ) ;
+    // InternalRoom.g:22922:1: rule__StringLiteral__Group__1__Impl : ( ( rule__StringLiteral__ValueAssignment_1 ) ) ;
     public final void rule__StringLiteral__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22697:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) )
-            // InternalRoom.g:22698:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22926:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22927:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22698:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22699:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22927:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22928:1: ( rule__StringLiteral__ValueAssignment_1 )
             {
              before(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); 
-            // InternalRoom.g:22700:1: ( rule__StringLiteral__ValueAssignment_1 )
-            // InternalRoom.g:22700:2: rule__StringLiteral__ValueAssignment_1
+            // InternalRoom.g:22929:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22929:2: rule__StringLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__ValueAssignment_1();
@@ -61636,16 +62295,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__0"
-    // InternalRoom.g:22714:1: rule__Integer__Group_0__0 : rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ;
+    // InternalRoom.g:22943:1: rule__Integer__Group_0__0 : rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ;
     public final void rule__Integer__Group_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22718:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 )
-            // InternalRoom.g:22719:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1
+            // InternalRoom.g:22947:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 )
+            // InternalRoom.g:22948:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1
             {
-            pushFollow(FOLLOW_119);
+            pushFollow(FOLLOW_120);
             rule__Integer__Group_0__0__Impl();
 
             state._fsp--;
@@ -61674,29 +62333,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__0__Impl"
-    // InternalRoom.g:22726:1: rule__Integer__Group_0__0__Impl : ( ( rule__Integer__Alternatives_0_0 )? ) ;
+    // InternalRoom.g:22955:1: rule__Integer__Group_0__0__Impl : ( ( rule__Integer__Alternatives_0_0 )? ) ;
     public final void rule__Integer__Group_0__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22730:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) )
-            // InternalRoom.g:22731:1: ( ( rule__Integer__Alternatives_0_0 )? )
+            // InternalRoom.g:22959:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) )
+            // InternalRoom.g:22960:1: ( ( rule__Integer__Alternatives_0_0 )? )
             {
-            // InternalRoom.g:22731:1: ( ( rule__Integer__Alternatives_0_0 )? )
-            // InternalRoom.g:22732:1: ( rule__Integer__Alternatives_0_0 )?
+            // InternalRoom.g:22960:1: ( ( rule__Integer__Alternatives_0_0 )? )
+            // InternalRoom.g:22961:1: ( rule__Integer__Alternatives_0_0 )?
             {
              before(grammarAccess.getIntegerAccess().getAlternatives_0_0()); 
-            // InternalRoom.g:22733:1: ( rule__Integer__Alternatives_0_0 )?
-            int alt201=2;
-            int LA201_0 = input.LA(1);
+            // InternalRoom.g:22962:1: ( rule__Integer__Alternatives_0_0 )?
+            int alt204=2;
+            int LA204_0 = input.LA(1);
 
-            if ( ((LA201_0>=29 && LA201_0<=30)) ) {
-                alt201=1;
+            if ( ((LA204_0>=29 && LA204_0<=30)) ) {
+                alt204=1;
             }
-            switch (alt201) {
+            switch (alt204) {
                 case 1 :
-                    // InternalRoom.g:22733:2: rule__Integer__Alternatives_0_0
+                    // InternalRoom.g:22962:2: rule__Integer__Alternatives_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Alternatives_0_0();
@@ -61732,14 +62391,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__1"
-    // InternalRoom.g:22743:1: rule__Integer__Group_0__1 : rule__Integer__Group_0__1__Impl ;
+    // InternalRoom.g:22972:1: rule__Integer__Group_0__1 : rule__Integer__Group_0__1__Impl ;
     public final void rule__Integer__Group_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22747:1: ( rule__Integer__Group_0__1__Impl )
-            // InternalRoom.g:22748:2: rule__Integer__Group_0__1__Impl
+            // InternalRoom.g:22976:1: ( rule__Integer__Group_0__1__Impl )
+            // InternalRoom.g:22977:2: rule__Integer__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Group_0__1__Impl();
@@ -61765,17 +62424,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Group_0__1__Impl"
-    // InternalRoom.g:22754:1: rule__Integer__Group_0__1__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:22983:1: rule__Integer__Group_0__1__Impl : ( RULE_INT ) ;
     public final void rule__Integer__Group_0__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22758:1: ( ( RULE_INT ) )
-            // InternalRoom.g:22759:1: ( RULE_INT )
+            // InternalRoom.g:22987:1: ( ( RULE_INT ) )
+            // InternalRoom.g:22988:1: ( RULE_INT )
             {
-            // InternalRoom.g:22759:1: ( RULE_INT )
-            // InternalRoom.g:22760:1: RULE_INT
+            // InternalRoom.g:22988:1: ( RULE_INT )
+            // InternalRoom.g:22989:1: RULE_INT
             {
              before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_0_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -61802,16 +62461,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__0"
-    // InternalRoom.g:22775:1: rule__Decimal__Group__0 : rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ;
+    // InternalRoom.g:23004:1: rule__Decimal__Group__0 : rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ;
     public final void rule__Decimal__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22779:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 )
-            // InternalRoom.g:22780:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1
+            // InternalRoom.g:23008:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 )
+            // InternalRoom.g:23009:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1
             {
-            pushFollow(FOLLOW_119);
+            pushFollow(FOLLOW_120);
             rule__Decimal__Group__0__Impl();
 
             state._fsp--;
@@ -61840,29 +62499,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__0__Impl"
-    // InternalRoom.g:22787:1: rule__Decimal__Group__0__Impl : ( ( rule__Decimal__Alternatives_0 )? ) ;
+    // InternalRoom.g:23016:1: rule__Decimal__Group__0__Impl : ( ( rule__Decimal__Alternatives_0 )? ) ;
     public final void rule__Decimal__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22791:1: ( ( ( rule__Decimal__Alternatives_0 )? ) )
-            // InternalRoom.g:22792:1: ( ( rule__Decimal__Alternatives_0 )? )
+            // InternalRoom.g:23020:1: ( ( ( rule__Decimal__Alternatives_0 )? ) )
+            // InternalRoom.g:23021:1: ( ( rule__Decimal__Alternatives_0 )? )
             {
-            // InternalRoom.g:22792:1: ( ( rule__Decimal__Alternatives_0 )? )
-            // InternalRoom.g:22793:1: ( rule__Decimal__Alternatives_0 )?
+            // InternalRoom.g:23021:1: ( ( rule__Decimal__Alternatives_0 )? )
+            // InternalRoom.g:23022:1: ( rule__Decimal__Alternatives_0 )?
             {
              before(grammarAccess.getDecimalAccess().getAlternatives_0()); 
-            // InternalRoom.g:22794:1: ( rule__Decimal__Alternatives_0 )?
-            int alt202=2;
-            int LA202_0 = input.LA(1);
+            // InternalRoom.g:23023:1: ( rule__Decimal__Alternatives_0 )?
+            int alt205=2;
+            int LA205_0 = input.LA(1);
 
-            if ( ((LA202_0>=29 && LA202_0<=30)) ) {
-                alt202=1;
+            if ( ((LA205_0>=29 && LA205_0<=30)) ) {
+                alt205=1;
             }
-            switch (alt202) {
+            switch (alt205) {
                 case 1 :
-                    // InternalRoom.g:22794:2: rule__Decimal__Alternatives_0
+                    // InternalRoom.g:23023:2: rule__Decimal__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Decimal__Alternatives_0();
@@ -61898,16 +62557,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__1"
-    // InternalRoom.g:22804:1: rule__Decimal__Group__1 : rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ;
+    // InternalRoom.g:23033:1: rule__Decimal__Group__1 : rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ;
     public final void rule__Decimal__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22808:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 )
-            // InternalRoom.g:22809:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2
+            // InternalRoom.g:23037:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 )
+            // InternalRoom.g:23038:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2
             {
-            pushFollow(FOLLOW_73);
+            pushFollow(FOLLOW_74);
             rule__Decimal__Group__1__Impl();
 
             state._fsp--;
@@ -61936,17 +62595,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__1__Impl"
-    // InternalRoom.g:22816:1: rule__Decimal__Group__1__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:23045:1: rule__Decimal__Group__1__Impl : ( RULE_INT ) ;
     public final void rule__Decimal__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22820:1: ( ( RULE_INT ) )
-            // InternalRoom.g:22821:1: ( RULE_INT )
+            // InternalRoom.g:23049:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23050:1: ( RULE_INT )
             {
-            // InternalRoom.g:22821:1: ( RULE_INT )
-            // InternalRoom.g:22822:1: RULE_INT
+            // InternalRoom.g:23050:1: ( RULE_INT )
+            // InternalRoom.g:23051:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -61973,14 +62632,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__2"
-    // InternalRoom.g:22833:1: rule__Decimal__Group__2 : rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ;
+    // InternalRoom.g:23062:1: rule__Decimal__Group__2 : rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ;
     public final void rule__Decimal__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22837:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 )
-            // InternalRoom.g:22838:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3
+            // InternalRoom.g:23066:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 )
+            // InternalRoom.g:23067:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3
             {
             pushFollow(FOLLOW_30);
             rule__Decimal__Group__2__Impl();
@@ -62011,17 +62670,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__2__Impl"
-    // InternalRoom.g:22845:1: rule__Decimal__Group__2__Impl : ( '.' ) ;
+    // InternalRoom.g:23074:1: rule__Decimal__Group__2__Impl : ( '.' ) ;
     public final void rule__Decimal__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22849:1: ( ( '.' ) )
-            // InternalRoom.g:22850:1: ( '.' )
+            // InternalRoom.g:23078:1: ( ( '.' ) )
+            // InternalRoom.g:23079:1: ( '.' )
             {
-            // InternalRoom.g:22850:1: ( '.' )
-            // InternalRoom.g:22851:1: '.'
+            // InternalRoom.g:23079:1: ( '.' )
+            // InternalRoom.g:23080:1: '.'
             {
              before(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); 
             match(input,87,FOLLOW_2); 
@@ -62048,14 +62707,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__3"
-    // InternalRoom.g:22864:1: rule__Decimal__Group__3 : rule__Decimal__Group__3__Impl ;
+    // InternalRoom.g:23093:1: rule__Decimal__Group__3 : rule__Decimal__Group__3__Impl ;
     public final void rule__Decimal__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22868:1: ( rule__Decimal__Group__3__Impl )
-            // InternalRoom.g:22869:2: rule__Decimal__Group__3__Impl
+            // InternalRoom.g:23097:1: ( rule__Decimal__Group__3__Impl )
+            // InternalRoom.g:23098:2: rule__Decimal__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__3__Impl();
@@ -62081,17 +62740,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__3__Impl"
-    // InternalRoom.g:22875:1: rule__Decimal__Group__3__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:23104:1: rule__Decimal__Group__3__Impl : ( RULE_INT ) ;
     public final void rule__Decimal__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22879:1: ( ( RULE_INT ) )
-            // InternalRoom.g:22880:1: ( RULE_INT )
+            // InternalRoom.g:23108:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23109:1: ( RULE_INT )
             {
-            // InternalRoom.g:22880:1: ( RULE_INT )
-            // InternalRoom.g:22881:1: RULE_INT
+            // InternalRoom.g:23109:1: ( RULE_INT )
+            // InternalRoom.g:23110:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62118,14 +62777,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__0"
-    // InternalRoom.g:22900:1: rule__DecimalExp__Group__0 : rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ;
+    // InternalRoom.g:23129:1: rule__DecimalExp__Group__0 : rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ;
     public final void rule__DecimalExp__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22904:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 )
-            // InternalRoom.g:22905:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1
+            // InternalRoom.g:23133:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 )
+            // InternalRoom.g:23134:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__DecimalExp__Group__0__Impl();
@@ -62156,29 +62815,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__0__Impl"
-    // InternalRoom.g:22912:1: rule__DecimalExp__Group__0__Impl : ( ( rule__DecimalExp__Alternatives_0 )? ) ;
+    // InternalRoom.g:23141:1: rule__DecimalExp__Group__0__Impl : ( ( rule__DecimalExp__Alternatives_0 )? ) ;
     public final void rule__DecimalExp__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22916:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) )
-            // InternalRoom.g:22917:1: ( ( rule__DecimalExp__Alternatives_0 )? )
+            // InternalRoom.g:23145:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) )
+            // InternalRoom.g:23146:1: ( ( rule__DecimalExp__Alternatives_0 )? )
             {
-            // InternalRoom.g:22917:1: ( ( rule__DecimalExp__Alternatives_0 )? )
-            // InternalRoom.g:22918:1: ( rule__DecimalExp__Alternatives_0 )?
+            // InternalRoom.g:23146:1: ( ( rule__DecimalExp__Alternatives_0 )? )
+            // InternalRoom.g:23147:1: ( rule__DecimalExp__Alternatives_0 )?
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_0()); 
-            // InternalRoom.g:22919:1: ( rule__DecimalExp__Alternatives_0 )?
-            int alt203=2;
-            int LA203_0 = input.LA(1);
+            // InternalRoom.g:23148:1: ( rule__DecimalExp__Alternatives_0 )?
+            int alt206=2;
+            int LA206_0 = input.LA(1);
 
-            if ( ((LA203_0>=29 && LA203_0<=30)) ) {
-                alt203=1;
+            if ( ((LA206_0>=29 && LA206_0<=30)) ) {
+                alt206=1;
             }
-            switch (alt203) {
+            switch (alt206) {
                 case 1 :
-                    // InternalRoom.g:22919:2: rule__DecimalExp__Alternatives_0
+                    // InternalRoom.g:23148:2: rule__DecimalExp__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_0();
@@ -62214,16 +62873,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__1"
-    // InternalRoom.g:22929:1: rule__DecimalExp__Group__1 : rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ;
+    // InternalRoom.g:23158:1: rule__DecimalExp__Group__1 : rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ;
     public final void rule__DecimalExp__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22933:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 )
-            // InternalRoom.g:22934:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2
+            // InternalRoom.g:23162:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 )
+            // InternalRoom.g:23163:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2
             {
-            pushFollow(FOLLOW_73);
+            pushFollow(FOLLOW_74);
             rule__DecimalExp__Group__1__Impl();
 
             state._fsp--;
@@ -62252,17 +62911,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__1__Impl"
-    // InternalRoom.g:22941:1: rule__DecimalExp__Group__1__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:23170:1: rule__DecimalExp__Group__1__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22945:1: ( ( RULE_INT ) )
-            // InternalRoom.g:22946:1: ( RULE_INT )
+            // InternalRoom.g:23174:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23175:1: ( RULE_INT )
             {
-            // InternalRoom.g:22946:1: ( RULE_INT )
-            // InternalRoom.g:22947:1: RULE_INT
+            // InternalRoom.g:23175:1: ( RULE_INT )
+            // InternalRoom.g:23176:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62289,14 +62948,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__2"
-    // InternalRoom.g:22958:1: rule__DecimalExp__Group__2 : rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ;
+    // InternalRoom.g:23187:1: rule__DecimalExp__Group__2 : rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ;
     public final void rule__DecimalExp__Group__2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22962:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 )
-            // InternalRoom.g:22963:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3
+            // InternalRoom.g:23191:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 )
+            // InternalRoom.g:23192:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3
             {
             pushFollow(FOLLOW_30);
             rule__DecimalExp__Group__2__Impl();
@@ -62327,17 +62986,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__2__Impl"
-    // InternalRoom.g:22970:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ;
+    // InternalRoom.g:23199:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ;
     public final void rule__DecimalExp__Group__2__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22974:1: ( ( '.' ) )
-            // InternalRoom.g:22975:1: ( '.' )
+            // InternalRoom.g:23203:1: ( ( '.' ) )
+            // InternalRoom.g:23204:1: ( '.' )
             {
-            // InternalRoom.g:22975:1: ( '.' )
-            // InternalRoom.g:22976:1: '.'
+            // InternalRoom.g:23204:1: ( '.' )
+            // InternalRoom.g:23205:1: '.'
             {
              before(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); 
             match(input,87,FOLLOW_2); 
@@ -62364,16 +63023,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__3"
-    // InternalRoom.g:22989:1: rule__DecimalExp__Group__3 : rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ;
+    // InternalRoom.g:23218:1: rule__DecimalExp__Group__3 : rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ;
     public final void rule__DecimalExp__Group__3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:22993:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 )
-            // InternalRoom.g:22994:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4
+            // InternalRoom.g:23222:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 )
+            // InternalRoom.g:23223:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4
             {
-            pushFollow(FOLLOW_120);
+            pushFollow(FOLLOW_121);
             rule__DecimalExp__Group__3__Impl();
 
             state._fsp--;
@@ -62402,17 +63061,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__3__Impl"
-    // InternalRoom.g:23001:1: rule__DecimalExp__Group__3__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:23230:1: rule__DecimalExp__Group__3__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23005:1: ( ( RULE_INT ) )
-            // InternalRoom.g:23006:1: ( RULE_INT )
+            // InternalRoom.g:23234:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23235:1: ( RULE_INT )
             {
-            // InternalRoom.g:23006:1: ( RULE_INT )
-            // InternalRoom.g:23007:1: RULE_INT
+            // InternalRoom.g:23235:1: ( RULE_INT )
+            // InternalRoom.g:23236:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62439,16 +63098,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__4"
-    // InternalRoom.g:23018:1: rule__DecimalExp__Group__4 : rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ;
+    // InternalRoom.g:23247:1: rule__DecimalExp__Group__4 : rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ;
     public final void rule__DecimalExp__Group__4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23022:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 )
-            // InternalRoom.g:23023:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5
+            // InternalRoom.g:23251:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 )
+            // InternalRoom.g:23252:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5
             {
-            pushFollow(FOLLOW_119);
+            pushFollow(FOLLOW_120);
             rule__DecimalExp__Group__4__Impl();
 
             state._fsp--;
@@ -62477,21 +63136,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__4__Impl"
-    // InternalRoom.g:23030:1: rule__DecimalExp__Group__4__Impl : ( ( rule__DecimalExp__Alternatives_4 ) ) ;
+    // InternalRoom.g:23259:1: rule__DecimalExp__Group__4__Impl : ( ( rule__DecimalExp__Alternatives_4 ) ) ;
     public final void rule__DecimalExp__Group__4__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23034:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) )
-            // InternalRoom.g:23035:1: ( ( rule__DecimalExp__Alternatives_4 ) )
+            // InternalRoom.g:23263:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) )
+            // InternalRoom.g:23264:1: ( ( rule__DecimalExp__Alternatives_4 ) )
             {
-            // InternalRoom.g:23035:1: ( ( rule__DecimalExp__Alternatives_4 ) )
-            // InternalRoom.g:23036:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalRoom.g:23264:1: ( ( rule__DecimalExp__Alternatives_4 ) )
+            // InternalRoom.g:23265:1: ( rule__DecimalExp__Alternatives_4 )
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_4()); 
-            // InternalRoom.g:23037:1: ( rule__DecimalExp__Alternatives_4 )
-            // InternalRoom.g:23037:2: rule__DecimalExp__Alternatives_4
+            // InternalRoom.g:23266:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalRoom.g:23266:2: rule__DecimalExp__Alternatives_4
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Alternatives_4();
@@ -62524,16 +63183,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__5"
-    // InternalRoom.g:23047:1: rule__DecimalExp__Group__5 : rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ;
+    // InternalRoom.g:23276:1: rule__DecimalExp__Group__5 : rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ;
     public final void rule__DecimalExp__Group__5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23051:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 )
-            // InternalRoom.g:23052:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6
+            // InternalRoom.g:23280:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 )
+            // InternalRoom.g:23281:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6
             {
-            pushFollow(FOLLOW_119);
+            pushFollow(FOLLOW_120);
             rule__DecimalExp__Group__5__Impl();
 
             state._fsp--;
@@ -62562,29 +63221,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__5__Impl"
-    // InternalRoom.g:23059:1: rule__DecimalExp__Group__5__Impl : ( ( rule__DecimalExp__Alternatives_5 )? ) ;
+    // InternalRoom.g:23288:1: rule__DecimalExp__Group__5__Impl : ( ( rule__DecimalExp__Alternatives_5 )? ) ;
     public final void rule__DecimalExp__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23063:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) )
-            // InternalRoom.g:23064:1: ( ( rule__DecimalExp__Alternatives_5 )? )
+            // InternalRoom.g:23292:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) )
+            // InternalRoom.g:23293:1: ( ( rule__DecimalExp__Alternatives_5 )? )
             {
-            // InternalRoom.g:23064:1: ( ( rule__DecimalExp__Alternatives_5 )? )
-            // InternalRoom.g:23065:1: ( rule__DecimalExp__Alternatives_5 )?
+            // InternalRoom.g:23293:1: ( ( rule__DecimalExp__Alternatives_5 )? )
+            // InternalRoom.g:23294:1: ( rule__DecimalExp__Alternatives_5 )?
             {
              before(grammarAccess.getDecimalExpAccess().getAlternatives_5()); 
-            // InternalRoom.g:23066:1: ( rule__DecimalExp__Alternatives_5 )?
-            int alt204=2;
-            int LA204_0 = input.LA(1);
+            // InternalRoom.g:23295:1: ( rule__DecimalExp__Alternatives_5 )?
+            int alt207=2;
+            int LA207_0 = input.LA(1);
 
-            if ( ((LA204_0>=29 && LA204_0<=30)) ) {
-                alt204=1;
+            if ( ((LA207_0>=29 && LA207_0<=30)) ) {
+                alt207=1;
             }
-            switch (alt204) {
+            switch (alt207) {
                 case 1 :
-                    // InternalRoom.g:23066:2: rule__DecimalExp__Alternatives_5
+                    // InternalRoom.g:23295:2: rule__DecimalExp__Alternatives_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_5();
@@ -62620,14 +63279,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__6"
-    // InternalRoom.g:23076:1: rule__DecimalExp__Group__6 : rule__DecimalExp__Group__6__Impl ;
+    // InternalRoom.g:23305:1: rule__DecimalExp__Group__6 : rule__DecimalExp__Group__6__Impl ;
     public final void rule__DecimalExp__Group__6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23080:1: ( rule__DecimalExp__Group__6__Impl )
-            // InternalRoom.g:23081:2: rule__DecimalExp__Group__6__Impl
+            // InternalRoom.g:23309:1: ( rule__DecimalExp__Group__6__Impl )
+            // InternalRoom.g:23310:2: rule__DecimalExp__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__6__Impl();
@@ -62653,17 +63312,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__6__Impl"
-    // InternalRoom.g:23087:1: rule__DecimalExp__Group__6__Impl : ( RULE_INT ) ;
+    // InternalRoom.g:23316:1: rule__DecimalExp__Group__6__Impl : ( RULE_INT ) ;
     public final void rule__DecimalExp__Group__6__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23091:1: ( ( RULE_INT ) )
-            // InternalRoom.g:23092:1: ( RULE_INT )
+            // InternalRoom.g:23320:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23321:1: ( RULE_INT )
             {
-            // InternalRoom.g:23092:1: ( RULE_INT )
-            // InternalRoom.g:23093:1: RULE_INT
+            // InternalRoom.g:23321:1: ( RULE_INT )
+            // InternalRoom.g:23322:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_6()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62690,16 +63349,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__0"
-    // InternalRoom.g:23118:1: rule__FQN__Group__0 : rule__FQN__Group__0__Impl rule__FQN__Group__1 ;
+    // InternalRoom.g:23347:1: rule__FQN__Group__0 : rule__FQN__Group__0__Impl rule__FQN__Group__1 ;
     public final void rule__FQN__Group__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23122:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 )
-            // InternalRoom.g:23123:2: rule__FQN__Group__0__Impl rule__FQN__Group__1
+            // InternalRoom.g:23351:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 )
+            // InternalRoom.g:23352:2: rule__FQN__Group__0__Impl rule__FQN__Group__1
             {
-            pushFollow(FOLLOW_73);
+            pushFollow(FOLLOW_74);
             rule__FQN__Group__0__Impl();
 
             state._fsp--;
@@ -62728,17 +63387,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__0__Impl"
-    // InternalRoom.g:23130:1: rule__FQN__Group__0__Impl : ( RULE_ID ) ;
+    // InternalRoom.g:23359:1: rule__FQN__Group__0__Impl : ( RULE_ID ) ;
     public final void rule__FQN__Group__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23134:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23135:1: ( RULE_ID )
+            // InternalRoom.g:23363:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23364:1: ( RULE_ID )
             {
-            // InternalRoom.g:23135:1: ( RULE_ID )
-            // InternalRoom.g:23136:1: RULE_ID
+            // InternalRoom.g:23364:1: ( RULE_ID )
+            // InternalRoom.g:23365:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -62765,14 +63424,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__1"
-    // InternalRoom.g:23147:1: rule__FQN__Group__1 : rule__FQN__Group__1__Impl ;
+    // InternalRoom.g:23376:1: rule__FQN__Group__1 : rule__FQN__Group__1__Impl ;
     public final void rule__FQN__Group__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23151:1: ( rule__FQN__Group__1__Impl )
-            // InternalRoom.g:23152:2: rule__FQN__Group__1__Impl
+            // InternalRoom.g:23380:1: ( rule__FQN__Group__1__Impl )
+            // InternalRoom.g:23381:2: rule__FQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__1__Impl();
@@ -62798,35 +63457,35 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group__1__Impl"
-    // InternalRoom.g:23158:1: rule__FQN__Group__1__Impl : ( ( rule__FQN__Group_1__0 )* ) ;
+    // InternalRoom.g:23387:1: rule__FQN__Group__1__Impl : ( ( rule__FQN__Group_1__0 )* ) ;
     public final void rule__FQN__Group__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23162:1: ( ( ( rule__FQN__Group_1__0 )* ) )
-            // InternalRoom.g:23163:1: ( ( rule__FQN__Group_1__0 )* )
+            // InternalRoom.g:23391:1: ( ( ( rule__FQN__Group_1__0 )* ) )
+            // InternalRoom.g:23392:1: ( ( rule__FQN__Group_1__0 )* )
             {
-            // InternalRoom.g:23163:1: ( ( rule__FQN__Group_1__0 )* )
-            // InternalRoom.g:23164:1: ( rule__FQN__Group_1__0 )*
+            // InternalRoom.g:23392:1: ( ( rule__FQN__Group_1__0 )* )
+            // InternalRoom.g:23393:1: ( rule__FQN__Group_1__0 )*
             {
              before(grammarAccess.getFQNAccess().getGroup_1()); 
-            // InternalRoom.g:23165:1: ( rule__FQN__Group_1__0 )*
-            loop205:
+            // InternalRoom.g:23394:1: ( rule__FQN__Group_1__0 )*
+            loop208:
             do {
-                int alt205=2;
-                int LA205_0 = input.LA(1);
+                int alt208=2;
+                int LA208_0 = input.LA(1);
 
-                if ( (LA205_0==87) ) {
-                    alt205=1;
+                if ( (LA208_0==87) ) {
+                    alt208=1;
                 }
 
 
-                switch (alt205) {
+                switch (alt208) {
             	case 1 :
-            	    // InternalRoom.g:23165:2: rule__FQN__Group_1__0
+            	    // InternalRoom.g:23394:2: rule__FQN__Group_1__0
             	    {
-            	    pushFollow(FOLLOW_121);
+            	    pushFollow(FOLLOW_122);
             	    rule__FQN__Group_1__0();
 
             	    state._fsp--;
@@ -62836,7 +63495,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop205;
+            	    break loop208;
                 }
             } while (true);
 
@@ -62863,14 +63522,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__0"
-    // InternalRoom.g:23179:1: rule__FQN__Group_1__0 : rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ;
+    // InternalRoom.g:23408:1: rule__FQN__Group_1__0 : rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ;
     public final void rule__FQN__Group_1__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23183:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 )
-            // InternalRoom.g:23184:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1
+            // InternalRoom.g:23412:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 )
+            // InternalRoom.g:23413:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1
             {
             pushFollow(FOLLOW_3);
             rule__FQN__Group_1__0__Impl();
@@ -62901,17 +63560,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__0__Impl"
-    // InternalRoom.g:23191:1: rule__FQN__Group_1__0__Impl : ( '.' ) ;
+    // InternalRoom.g:23420:1: rule__FQN__Group_1__0__Impl : ( '.' ) ;
     public final void rule__FQN__Group_1__0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23195:1: ( ( '.' ) )
-            // InternalRoom.g:23196:1: ( '.' )
+            // InternalRoom.g:23424:1: ( ( '.' ) )
+            // InternalRoom.g:23425:1: ( '.' )
             {
-            // InternalRoom.g:23196:1: ( '.' )
-            // InternalRoom.g:23197:1: '.'
+            // InternalRoom.g:23425:1: ( '.' )
+            // InternalRoom.g:23426:1: '.'
             {
              before(grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); 
             match(input,87,FOLLOW_2); 
@@ -62938,14 +63597,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__1"
-    // InternalRoom.g:23210:1: rule__FQN__Group_1__1 : rule__FQN__Group_1__1__Impl ;
+    // InternalRoom.g:23439:1: rule__FQN__Group_1__1 : rule__FQN__Group_1__1__Impl ;
     public final void rule__FQN__Group_1__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23214:1: ( rule__FQN__Group_1__1__Impl )
-            // InternalRoom.g:23215:2: rule__FQN__Group_1__1__Impl
+            // InternalRoom.g:23443:1: ( rule__FQN__Group_1__1__Impl )
+            // InternalRoom.g:23444:2: rule__FQN__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group_1__1__Impl();
@@ -62971,17 +63630,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__FQN__Group_1__1__Impl"
-    // InternalRoom.g:23221:1: rule__FQN__Group_1__1__Impl : ( RULE_ID ) ;
+    // InternalRoom.g:23450:1: rule__FQN__Group_1__1__Impl : ( RULE_ID ) ;
     public final void rule__FQN__Group_1__1__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23225:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23226:1: ( RULE_ID )
+            // InternalRoom.g:23454:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23455:1: ( RULE_ID )
             {
-            // InternalRoom.g:23226:1: ( RULE_ID )
-            // InternalRoom.g:23227:1: RULE_ID
+            // InternalRoom.g:23455:1: ( RULE_ID )
+            // InternalRoom.g:23456:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63008,29 +63667,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UnorderedGroup_0"
-    // InternalRoom.g:23243:1: rule__ActorClass__UnorderedGroup_0 : ( rule__ActorClass__UnorderedGroup_0__0 )? ;
+    // InternalRoom.g:23472:1: rule__ActorClass__UnorderedGroup_0 : ( rule__ActorClass__UnorderedGroup_0__0 )? ;
     public final void rule__ActorClass__UnorderedGroup_0() throws RecognitionException {
 
             	int stackSize = keepStackSize();
         		getUnorderedGroupHelper().enter(grammarAccess.getActorClassAccess().getUnorderedGroup_0());
             
         try {
-            // InternalRoom.g:23248:1: ( ( rule__ActorClass__UnorderedGroup_0__0 )? )
-            // InternalRoom.g:23249:2: ( rule__ActorClass__UnorderedGroup_0__0 )?
+            // InternalRoom.g:23477:1: ( ( rule__ActorClass__UnorderedGroup_0__0 )? )
+            // InternalRoom.g:23478:2: ( rule__ActorClass__UnorderedGroup_0__0 )?
             {
-            // InternalRoom.g:23249:2: ( rule__ActorClass__UnorderedGroup_0__0 )?
-            int alt206=2;
-            int LA206_0 = input.LA(1);
+            // InternalRoom.g:23478:2: ( rule__ActorClass__UnorderedGroup_0__0 )?
+            int alt209=2;
+            int LA209_0 = input.LA(1);
 
-            if ( LA206_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt206=1;
+            if ( LA209_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt209=1;
             }
-            else if ( ( LA206_0 >= 33 && LA206_0 <= 35 || LA206_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt206=1;
+            else if ( ( LA209_0 >= 33 && LA209_0 <= 35 || LA209_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt209=1;
             }
-            switch (alt206) {
+            switch (alt209) {
                 case 1 :
-                    // InternalRoom.g:23249:2: rule__ActorClass__UnorderedGroup_0__0
+                    // InternalRoom.g:23478:2: rule__ActorClass__UnorderedGroup_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__UnorderedGroup_0__0();
@@ -63063,44 +63722,44 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UnorderedGroup_0__Impl"
-    // InternalRoom.g:23259:1: rule__ActorClass__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) ) ;
+    // InternalRoom.g:23488:1: rule__ActorClass__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) ) ;
     public final void rule__ActorClass__UnorderedGroup_0__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
         		boolean selected = false;
             
         try {
-            // InternalRoom.g:23264:1: ( ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) ) )
-            // InternalRoom.g:23265:3: ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) )
+            // InternalRoom.g:23493:1: ( ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) ) )
+            // InternalRoom.g:23494:3: ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) )
             {
-            // InternalRoom.g:23265:3: ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) )
-            int alt207=2;
-            int LA207_0 = input.LA(1);
+            // InternalRoom.g:23494:3: ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) )
+            int alt210=2;
+            int LA210_0 = input.LA(1);
 
-            if ( LA207_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt207=1;
+            if ( LA210_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt210=1;
             }
-            else if ( ( LA207_0 >= 33 && LA207_0 <= 35 || LA207_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt207=2;
+            else if ( ( LA210_0 >= 33 && LA210_0 <= 35 || LA210_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt210=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 207, 0, input);
+                    new NoViableAltException("", 210, 0, input);
 
                 throw nvae;
             }
-            switch (alt207) {
+            switch (alt210) {
                 case 1 :
-                    // InternalRoom.g:23267:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
+                    // InternalRoom.g:23496:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
                     {
-                    // InternalRoom.g:23267:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
-                    // InternalRoom.g:23268:5: {...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) )
+                    // InternalRoom.g:23496:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
+                    // InternalRoom.g:23497:5: {...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) )
                     {
                     if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
                         throw new FailedPredicateException(input, "rule__ActorClass__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0)");
                     }
-                    // InternalRoom.g:23268:107: ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) )
-                    // InternalRoom.g:23269:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
+                    // InternalRoom.g:23497:107: ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) )
+                    // InternalRoom.g:23498:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0);
@@ -63108,12 +63767,12 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
                     	 				  selected = true;
                     	 				
-                    // InternalRoom.g:23275:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
-                    // InternalRoom.g:23277:7: ( rule__ActorClass__AbstractAssignment_0_0 )
+                    // InternalRoom.g:23504:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
+                    // InternalRoom.g:23506:7: ( rule__ActorClass__AbstractAssignment_0_0 )
                     {
                      before(grammarAccess.getActorClassAccess().getAbstractAssignment_0_0()); 
-                    // InternalRoom.g:23278:7: ( rule__ActorClass__AbstractAssignment_0_0 )
-                    // InternalRoom.g:23278:8: rule__ActorClass__AbstractAssignment_0_0
+                    // InternalRoom.g:23507:7: ( rule__ActorClass__AbstractAssignment_0_0 )
+                    // InternalRoom.g:23507:8: rule__ActorClass__AbstractAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__AbstractAssignment_0_0();
@@ -63137,16 +63796,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:23284:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalRoom.g:23513:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
                     {
-                    // InternalRoom.g:23284:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
-                    // InternalRoom.g:23285:5: {...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) )
+                    // InternalRoom.g:23513:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalRoom.g:23514:5: {...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) )
                     {
                     if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
                         throw new FailedPredicateException(input, "rule__ActorClass__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1)");
                     }
-                    // InternalRoom.g:23285:107: ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) )
-                    // InternalRoom.g:23286:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
+                    // InternalRoom.g:23514:107: ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) )
+                    // InternalRoom.g:23515:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1);
@@ -63154,12 +63813,12 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
                     	 				  selected = true;
                     	 				
-                    // InternalRoom.g:23292:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
-                    // InternalRoom.g:23294:7: ( rule__ActorClass__CommTypeAssignment_0_1 )
+                    // InternalRoom.g:23521:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
+                    // InternalRoom.g:23523:7: ( rule__ActorClass__CommTypeAssignment_0_1 )
                     {
                      before(grammarAccess.getActorClassAccess().getCommTypeAssignment_0_1()); 
-                    // InternalRoom.g:23295:7: ( rule__ActorClass__CommTypeAssignment_0_1 )
-                    // InternalRoom.g:23295:8: rule__ActorClass__CommTypeAssignment_0_1
+                    // InternalRoom.g:23524:7: ( rule__ActorClass__CommTypeAssignment_0_1 )
+                    // InternalRoom.g:23524:8: rule__ActorClass__CommTypeAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__CommTypeAssignment_0_1();
@@ -63206,33 +63865,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UnorderedGroup_0__0"
-    // InternalRoom.g:23310:1: rule__ActorClass__UnorderedGroup_0__0 : rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )? ;
+    // InternalRoom.g:23539:1: rule__ActorClass__UnorderedGroup_0__0 : rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )? ;
     public final void rule__ActorClass__UnorderedGroup_0__0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23314:1: ( rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )? )
-            // InternalRoom.g:23315:2: rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )?
+            // InternalRoom.g:23543:1: ( rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )? )
+            // InternalRoom.g:23544:2: rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )?
             {
-            pushFollow(FOLLOW_122);
+            pushFollow(FOLLOW_123);
             rule__ActorClass__UnorderedGroup_0__Impl();
 
             state._fsp--;
 
-            // InternalRoom.g:23316:2: ( rule__ActorClass__UnorderedGroup_0__1 )?
-            int alt208=2;
-            int LA208_0 = input.LA(1);
+            // InternalRoom.g:23545:2: ( rule__ActorClass__UnorderedGroup_0__1 )?
+            int alt211=2;
+            int LA211_0 = input.LA(1);
 
-            if ( LA208_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt208=1;
+            if ( LA211_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt211=1;
             }
-            else if ( ( LA208_0 >= 33 && LA208_0 <= 35 || LA208_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt208=1;
+            else if ( ( LA211_0 >= 33 && LA211_0 <= 35 || LA211_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt211=1;
             }
-            switch (alt208) {
+            switch (alt211) {
                 case 1 :
-                    // InternalRoom.g:23316:2: rule__ActorClass__UnorderedGroup_0__1
+                    // InternalRoom.g:23545:2: rule__ActorClass__UnorderedGroup_0__1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__UnorderedGroup_0__1();
@@ -63264,14 +63923,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UnorderedGroup_0__1"
-    // InternalRoom.g:23323:1: rule__ActorClass__UnorderedGroup_0__1 : rule__ActorClass__UnorderedGroup_0__Impl ;
+    // InternalRoom.g:23552:1: rule__ActorClass__UnorderedGroup_0__1 : rule__ActorClass__UnorderedGroup_0__Impl ;
     public final void rule__ActorClass__UnorderedGroup_0__1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23327:1: ( rule__ActorClass__UnorderedGroup_0__Impl )
-            // InternalRoom.g:23328:2: rule__ActorClass__UnorderedGroup_0__Impl
+            // InternalRoom.g:23556:1: ( rule__ActorClass__UnorderedGroup_0__Impl )
+            // InternalRoom.g:23557:2: rule__ActorClass__UnorderedGroup_0__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UnorderedGroup_0__Impl();
@@ -63297,17 +63956,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__NameAssignment_1"
-    // InternalRoom.g:23339:1: rule__RoomModel__NameAssignment_1 : ( ruleFQN ) ;
+    // InternalRoom.g:23568:1: rule__RoomModel__NameAssignment_1 : ( ruleFQN ) ;
     public final void rule__RoomModel__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23343:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23344:1: ( ruleFQN )
+            // InternalRoom.g:23572:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23573:1: ( ruleFQN )
             {
-            // InternalRoom.g:23344:1: ( ruleFQN )
-            // InternalRoom.g:23345:1: ruleFQN
+            // InternalRoom.g:23573:1: ( ruleFQN )
+            // InternalRoom.g:23574:1: ruleFQN
             {
              before(grammarAccess.getRoomModelAccess().getNameFQNParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -63338,17 +63997,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__DocuAssignment_2"
-    // InternalRoom.g:23354:1: rule__RoomModel__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23583:1: rule__RoomModel__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__RoomModel__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23358:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:23359:1: ( ruleDocumentation )
+            // InternalRoom.g:23587:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23588:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23359:1: ( ruleDocumentation )
-            // InternalRoom.g:23360:1: ruleDocumentation
+            // InternalRoom.g:23588:1: ( ruleDocumentation )
+            // InternalRoom.g:23589:1: ruleDocumentation
             {
              before(grammarAccess.getRoomModelAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63379,17 +64038,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__ImportsAssignment_4"
-    // InternalRoom.g:23369:1: rule__RoomModel__ImportsAssignment_4 : ( ruleImport ) ;
+    // InternalRoom.g:23598:1: rule__RoomModel__ImportsAssignment_4 : ( ruleImport ) ;
     public final void rule__RoomModel__ImportsAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23373:1: ( ( ruleImport ) )
-            // InternalRoom.g:23374:1: ( ruleImport )
+            // InternalRoom.g:23602:1: ( ( ruleImport ) )
+            // InternalRoom.g:23603:1: ( ruleImport )
             {
-            // InternalRoom.g:23374:1: ( ruleImport )
-            // InternalRoom.g:23375:1: ruleImport
+            // InternalRoom.g:23603:1: ( ruleImport )
+            // InternalRoom.g:23604:1: ruleImport
             {
              before(grammarAccess.getRoomModelAccess().getImportsImportParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -63420,17 +64079,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__PrimitiveTypesAssignment_5_0"
-    // InternalRoom.g:23384:1: rule__RoomModel__PrimitiveTypesAssignment_5_0 : ( rulePrimitiveType ) ;
+    // InternalRoom.g:23613:1: rule__RoomModel__PrimitiveTypesAssignment_5_0 : ( rulePrimitiveType ) ;
     public final void rule__RoomModel__PrimitiveTypesAssignment_5_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23388:1: ( ( rulePrimitiveType ) )
-            // InternalRoom.g:23389:1: ( rulePrimitiveType )
+            // InternalRoom.g:23617:1: ( ( rulePrimitiveType ) )
+            // InternalRoom.g:23618:1: ( rulePrimitiveType )
             {
-            // InternalRoom.g:23389:1: ( rulePrimitiveType )
-            // InternalRoom.g:23390:1: rulePrimitiveType
+            // InternalRoom.g:23618:1: ( rulePrimitiveType )
+            // InternalRoom.g:23619:1: rulePrimitiveType
             {
              before(grammarAccess.getRoomModelAccess().getPrimitiveTypesPrimitiveTypeParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -63461,17 +64120,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__EnumerationTypesAssignment_5_1"
-    // InternalRoom.g:23399:1: rule__RoomModel__EnumerationTypesAssignment_5_1 : ( ruleEnumerationType ) ;
+    // InternalRoom.g:23628:1: rule__RoomModel__EnumerationTypesAssignment_5_1 : ( ruleEnumerationType ) ;
     public final void rule__RoomModel__EnumerationTypesAssignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23403:1: ( ( ruleEnumerationType ) )
-            // InternalRoom.g:23404:1: ( ruleEnumerationType )
+            // InternalRoom.g:23632:1: ( ( ruleEnumerationType ) )
+            // InternalRoom.g:23633:1: ( ruleEnumerationType )
             {
-            // InternalRoom.g:23404:1: ( ruleEnumerationType )
-            // InternalRoom.g:23405:1: ruleEnumerationType
+            // InternalRoom.g:23633:1: ( ruleEnumerationType )
+            // InternalRoom.g:23634:1: ruleEnumerationType
             {
              before(grammarAccess.getRoomModelAccess().getEnumerationTypesEnumerationTypeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -63502,17 +64161,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__ExternalTypesAssignment_5_2"
-    // InternalRoom.g:23414:1: rule__RoomModel__ExternalTypesAssignment_5_2 : ( ruleExternalType ) ;
+    // InternalRoom.g:23643:1: rule__RoomModel__ExternalTypesAssignment_5_2 : ( ruleExternalType ) ;
     public final void rule__RoomModel__ExternalTypesAssignment_5_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23418:1: ( ( ruleExternalType ) )
-            // InternalRoom.g:23419:1: ( ruleExternalType )
+            // InternalRoom.g:23647:1: ( ( ruleExternalType ) )
+            // InternalRoom.g:23648:1: ( ruleExternalType )
             {
-            // InternalRoom.g:23419:1: ( ruleExternalType )
-            // InternalRoom.g:23420:1: ruleExternalType
+            // InternalRoom.g:23648:1: ( ruleExternalType )
+            // InternalRoom.g:23649:1: ruleExternalType
             {
              before(grammarAccess.getRoomModelAccess().getExternalTypesExternalTypeParserRuleCall_5_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63543,17 +64202,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__DataClassesAssignment_5_3"
-    // InternalRoom.g:23429:1: rule__RoomModel__DataClassesAssignment_5_3 : ( ruleDataClass ) ;
+    // InternalRoom.g:23658:1: rule__RoomModel__DataClassesAssignment_5_3 : ( ruleDataClass ) ;
     public final void rule__RoomModel__DataClassesAssignment_5_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23433:1: ( ( ruleDataClass ) )
-            // InternalRoom.g:23434:1: ( ruleDataClass )
+            // InternalRoom.g:23662:1: ( ( ruleDataClass ) )
+            // InternalRoom.g:23663:1: ( ruleDataClass )
             {
-            // InternalRoom.g:23434:1: ( ruleDataClass )
-            // InternalRoom.g:23435:1: ruleDataClass
+            // InternalRoom.g:23663:1: ( ruleDataClass )
+            // InternalRoom.g:23664:1: ruleDataClass
             {
              before(grammarAccess.getRoomModelAccess().getDataClassesDataClassParserRuleCall_5_3_0()); 
             pushFollow(FOLLOW_2);
@@ -63584,17 +64243,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__ProtocolClassesAssignment_5_4"
-    // InternalRoom.g:23444:1: rule__RoomModel__ProtocolClassesAssignment_5_4 : ( ruleGeneralProtocolClass ) ;
+    // InternalRoom.g:23673:1: rule__RoomModel__ProtocolClassesAssignment_5_4 : ( ruleGeneralProtocolClass ) ;
     public final void rule__RoomModel__ProtocolClassesAssignment_5_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23448:1: ( ( ruleGeneralProtocolClass ) )
-            // InternalRoom.g:23449:1: ( ruleGeneralProtocolClass )
+            // InternalRoom.g:23677:1: ( ( ruleGeneralProtocolClass ) )
+            // InternalRoom.g:23678:1: ( ruleGeneralProtocolClass )
             {
-            // InternalRoom.g:23449:1: ( ruleGeneralProtocolClass )
-            // InternalRoom.g:23450:1: ruleGeneralProtocolClass
+            // InternalRoom.g:23678:1: ( ruleGeneralProtocolClass )
+            // InternalRoom.g:23679:1: ruleGeneralProtocolClass
             {
              before(grammarAccess.getRoomModelAccess().getProtocolClassesGeneralProtocolClassParserRuleCall_5_4_0()); 
             pushFollow(FOLLOW_2);
@@ -63625,17 +64284,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__ActorClassesAssignment_5_5"
-    // InternalRoom.g:23459:1: rule__RoomModel__ActorClassesAssignment_5_5 : ( ruleActorClass ) ;
+    // InternalRoom.g:23688:1: rule__RoomModel__ActorClassesAssignment_5_5 : ( ruleActorClass ) ;
     public final void rule__RoomModel__ActorClassesAssignment_5_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23463:1: ( ( ruleActorClass ) )
-            // InternalRoom.g:23464:1: ( ruleActorClass )
+            // InternalRoom.g:23692:1: ( ( ruleActorClass ) )
+            // InternalRoom.g:23693:1: ( ruleActorClass )
             {
-            // InternalRoom.g:23464:1: ( ruleActorClass )
-            // InternalRoom.g:23465:1: ruleActorClass
+            // InternalRoom.g:23693:1: ( ruleActorClass )
+            // InternalRoom.g:23694:1: ruleActorClass
             {
              before(grammarAccess.getRoomModelAccess().getActorClassesActorClassParserRuleCall_5_5_0()); 
             pushFollow(FOLLOW_2);
@@ -63666,17 +64325,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__SubSystemClassesAssignment_5_6"
-    // InternalRoom.g:23474:1: rule__RoomModel__SubSystemClassesAssignment_5_6 : ( ruleSubSystemClass ) ;
+    // InternalRoom.g:23703:1: rule__RoomModel__SubSystemClassesAssignment_5_6 : ( ruleSubSystemClass ) ;
     public final void rule__RoomModel__SubSystemClassesAssignment_5_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23478:1: ( ( ruleSubSystemClass ) )
-            // InternalRoom.g:23479:1: ( ruleSubSystemClass )
+            // InternalRoom.g:23707:1: ( ( ruleSubSystemClass ) )
+            // InternalRoom.g:23708:1: ( ruleSubSystemClass )
             {
-            // InternalRoom.g:23479:1: ( ruleSubSystemClass )
-            // InternalRoom.g:23480:1: ruleSubSystemClass
+            // InternalRoom.g:23708:1: ( ruleSubSystemClass )
+            // InternalRoom.g:23709:1: ruleSubSystemClass
             {
              before(grammarAccess.getRoomModelAccess().getSubSystemClassesSubSystemClassParserRuleCall_5_6_0()); 
             pushFollow(FOLLOW_2);
@@ -63707,17 +64366,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__SystemsAssignment_5_7"
-    // InternalRoom.g:23489:1: rule__RoomModel__SystemsAssignment_5_7 : ( ruleLogicalSystem ) ;
+    // InternalRoom.g:23718:1: rule__RoomModel__SystemsAssignment_5_7 : ( ruleLogicalSystem ) ;
     public final void rule__RoomModel__SystemsAssignment_5_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23493:1: ( ( ruleLogicalSystem ) )
-            // InternalRoom.g:23494:1: ( ruleLogicalSystem )
+            // InternalRoom.g:23722:1: ( ( ruleLogicalSystem ) )
+            // InternalRoom.g:23723:1: ( ruleLogicalSystem )
             {
-            // InternalRoom.g:23494:1: ( ruleLogicalSystem )
-            // InternalRoom.g:23495:1: ruleLogicalSystem
+            // InternalRoom.g:23723:1: ( ruleLogicalSystem )
+            // InternalRoom.g:23724:1: ruleLogicalSystem
             {
              before(grammarAccess.getRoomModelAccess().getSystemsLogicalSystemParserRuleCall_5_7_0()); 
             pushFollow(FOLLOW_2);
@@ -63748,17 +64407,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__AnnotationTypesAssignment_5_8"
-    // InternalRoom.g:23504:1: rule__RoomModel__AnnotationTypesAssignment_5_8 : ( ruleAnnotationType ) ;
+    // InternalRoom.g:23733:1: rule__RoomModel__AnnotationTypesAssignment_5_8 : ( ruleAnnotationType ) ;
     public final void rule__RoomModel__AnnotationTypesAssignment_5_8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23508:1: ( ( ruleAnnotationType ) )
-            // InternalRoom.g:23509:1: ( ruleAnnotationType )
+            // InternalRoom.g:23737:1: ( ( ruleAnnotationType ) )
+            // InternalRoom.g:23738:1: ( ruleAnnotationType )
             {
-            // InternalRoom.g:23509:1: ( ruleAnnotationType )
-            // InternalRoom.g:23510:1: ruleAnnotationType
+            // InternalRoom.g:23738:1: ( ruleAnnotationType )
+            // InternalRoom.g:23739:1: ruleAnnotationType
             {
              before(grammarAccess.getRoomModelAccess().getAnnotationTypesAnnotationTypeParserRuleCall_5_8_0()); 
             pushFollow(FOLLOW_2);
@@ -63789,17 +64448,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__NameAssignment_0"
-    // InternalRoom.g:23519:1: rule__VarDecl__NameAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:23748:1: rule__VarDecl__NameAssignment_0 : ( RULE_ID ) ;
     public final void rule__VarDecl__NameAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23523:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23524:1: ( RULE_ID )
+            // InternalRoom.g:23752:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23753:1: ( RULE_ID )
             {
-            // InternalRoom.g:23524:1: ( RULE_ID )
-            // InternalRoom.g:23525:1: RULE_ID
+            // InternalRoom.g:23753:1: ( RULE_ID )
+            // InternalRoom.g:23754:1: RULE_ID
             {
              before(grammarAccess.getVarDeclAccess().getNameIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63826,17 +64485,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__RefTypeAssignment_2"
-    // InternalRoom.g:23534:1: rule__VarDecl__RefTypeAssignment_2 : ( ruleRefableType ) ;
+    // InternalRoom.g:23763:1: rule__VarDecl__RefTypeAssignment_2 : ( ruleRefableType ) ;
     public final void rule__VarDecl__RefTypeAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23538:1: ( ( ruleRefableType ) )
-            // InternalRoom.g:23539:1: ( ruleRefableType )
+            // InternalRoom.g:23767:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:23768:1: ( ruleRefableType )
             {
-            // InternalRoom.g:23539:1: ( ruleRefableType )
-            // InternalRoom.g:23540:1: ruleRefableType
+            // InternalRoom.g:23768:1: ( ruleRefableType )
+            // InternalRoom.g:23769:1: ruleRefableType
             {
              before(grammarAccess.getVarDeclAccess().getRefTypeRefableTypeParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63866,22 +64525,100 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__VarDecl__RefTypeAssignment_2"
 
 
+    // $ANTLR start "rule__MessageData__DeprecatedNameAssignment_0_0"
+    // InternalRoom.g:23778:1: rule__MessageData__DeprecatedNameAssignment_0_0 : ( RULE_ID ) ;
+    public final void rule__MessageData__DeprecatedNameAssignment_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:23782:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23783:1: ( RULE_ID )
+            {
+            // InternalRoom.g:23783:1: ( RULE_ID )
+            // InternalRoom.g:23784:1: RULE_ID
+            {
+             before(grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__DeprecatedNameAssignment_0_0"
+
+
+    // $ANTLR start "rule__MessageData__RefTypeAssignment_1"
+    // InternalRoom.g:23793:1: rule__MessageData__RefTypeAssignment_1 : ( ruleRefableType ) ;
+    public final void rule__MessageData__RefTypeAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:23797:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:23798:1: ( ruleRefableType )
+            {
+            // InternalRoom.g:23798:1: ( ruleRefableType )
+            // InternalRoom.g:23799:1: ruleRefableType
+            {
+             before(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleRefableType();
+
+            state._fsp--;
+
+             after(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MessageData__RefTypeAssignment_1"
+
+
     // $ANTLR start "rule__RefableType__TypeAssignment_0"
-    // InternalRoom.g:23549:1: rule__RefableType__TypeAssignment_0 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:23808:1: rule__RefableType__TypeAssignment_0 : ( ( ruleFQN ) ) ;
     public final void rule__RefableType__TypeAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23553:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:23554:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23812:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:23813:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23554:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23555:1: ( ruleFQN )
+            // InternalRoom.g:23813:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23814:1: ( ruleFQN )
             {
              before(grammarAccess.getRefableTypeAccess().getTypeDataTypeCrossReference_0_0()); 
-            // InternalRoom.g:23556:1: ( ruleFQN )
-            // InternalRoom.g:23557:1: ruleFQN
+            // InternalRoom.g:23815:1: ( ruleFQN )
+            // InternalRoom.g:23816:1: ruleFQN
             {
              before(grammarAccess.getRefableTypeAccess().getTypeDataTypeFQNParserRuleCall_0_0_1()); 
             pushFollow(FOLLOW_2);
@@ -63916,21 +64653,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__RefAssignment_1"
-    // InternalRoom.g:23568:1: rule__RefableType__RefAssignment_1 : ( ( 'ref' ) ) ;
+    // InternalRoom.g:23827:1: rule__RefableType__RefAssignment_1 : ( ( 'ref' ) ) ;
     public final void rule__RefableType__RefAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23572:1: ( ( ( 'ref' ) ) )
-            // InternalRoom.g:23573:1: ( ( 'ref' ) )
+            // InternalRoom.g:23831:1: ( ( ( 'ref' ) ) )
+            // InternalRoom.g:23832:1: ( ( 'ref' ) )
             {
-            // InternalRoom.g:23573:1: ( ( 'ref' ) )
-            // InternalRoom.g:23574:1: ( 'ref' )
+            // InternalRoom.g:23832:1: ( ( 'ref' ) )
+            // InternalRoom.g:23833:1: ( 'ref' )
             {
              before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); 
-            // InternalRoom.g:23575:1: ( 'ref' )
-            // InternalRoom.g:23576:1: 'ref'
+            // InternalRoom.g:23834:1: ( 'ref' )
+            // InternalRoom.g:23835:1: 'ref'
             {
              before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); 
             match(input,91,FOLLOW_2); 
@@ -63961,17 +64698,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__NameAssignment_1"
-    // InternalRoom.g:23591:1: rule__PrimitiveType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23850:1: rule__PrimitiveType__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__PrimitiveType__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23595:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23596:1: ( RULE_ID )
+            // InternalRoom.g:23854:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23855:1: ( RULE_ID )
             {
-            // InternalRoom.g:23596:1: ( RULE_ID )
-            // InternalRoom.g:23597:1: RULE_ID
+            // InternalRoom.g:23855:1: ( RULE_ID )
+            // InternalRoom.g:23856:1: RULE_ID
             {
              before(grammarAccess.getPrimitiveTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63998,17 +64735,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__TypeAssignment_3"
-    // InternalRoom.g:23606:1: rule__PrimitiveType__TypeAssignment_3 : ( ruleLiteralType ) ;
+    // InternalRoom.g:23865:1: rule__PrimitiveType__TypeAssignment_3 : ( ruleLiteralType ) ;
     public final void rule__PrimitiveType__TypeAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23610:1: ( ( ruleLiteralType ) )
-            // InternalRoom.g:23611:1: ( ruleLiteralType )
+            // InternalRoom.g:23869:1: ( ( ruleLiteralType ) )
+            // InternalRoom.g:23870:1: ( ruleLiteralType )
             {
-            // InternalRoom.g:23611:1: ( ruleLiteralType )
-            // InternalRoom.g:23612:1: ruleLiteralType
+            // InternalRoom.g:23870:1: ( ruleLiteralType )
+            // InternalRoom.g:23871:1: ruleLiteralType
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTypeLiteralTypeEnumRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -64039,17 +64776,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__TargetNameAssignment_5"
-    // InternalRoom.g:23621:1: rule__PrimitiveType__TargetNameAssignment_5 : ( RULE_STRING ) ;
+    // InternalRoom.g:23880:1: rule__PrimitiveType__TargetNameAssignment_5 : ( RULE_STRING ) ;
     public final void rule__PrimitiveType__TargetNameAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23625:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:23626:1: ( RULE_STRING )
+            // InternalRoom.g:23884:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23885:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23626:1: ( RULE_STRING )
-            // InternalRoom.g:23627:1: RULE_STRING
+            // InternalRoom.g:23885:1: ( RULE_STRING )
+            // InternalRoom.g:23886:1: RULE_STRING
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTargetNameSTRINGTerminalRuleCall_5_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64076,17 +64813,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__CastNameAssignment_6_1"
-    // InternalRoom.g:23636:1: rule__PrimitiveType__CastNameAssignment_6_1 : ( ruleFQN ) ;
+    // InternalRoom.g:23895:1: rule__PrimitiveType__CastNameAssignment_6_1 : ( ruleFQN ) ;
     public final void rule__PrimitiveType__CastNameAssignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23640:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23641:1: ( ruleFQN )
+            // InternalRoom.g:23899:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23900:1: ( ruleFQN )
             {
-            // InternalRoom.g:23641:1: ( ruleFQN )
-            // InternalRoom.g:23642:1: ruleFQN
+            // InternalRoom.g:23900:1: ( ruleFQN )
+            // InternalRoom.g:23901:1: ruleFQN
             {
              before(grammarAccess.getPrimitiveTypeAccess().getCastNameFQNParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64117,17 +64854,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__DefaultValueLiteralAssignment_8"
-    // InternalRoom.g:23651:1: rule__PrimitiveType__DefaultValueLiteralAssignment_8 : ( RULE_STRING ) ;
+    // InternalRoom.g:23910:1: rule__PrimitiveType__DefaultValueLiteralAssignment_8 : ( RULE_STRING ) ;
     public final void rule__PrimitiveType__DefaultValueLiteralAssignment_8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23655:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:23656:1: ( RULE_STRING )
+            // InternalRoom.g:23914:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23915:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23656:1: ( RULE_STRING )
-            // InternalRoom.g:23657:1: RULE_STRING
+            // InternalRoom.g:23915:1: ( RULE_STRING )
+            // InternalRoom.g:23916:1: RULE_STRING
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_8_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64154,17 +64891,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__DocuAssignment_9"
-    // InternalRoom.g:23666:1: rule__PrimitiveType__DocuAssignment_9 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23925:1: rule__PrimitiveType__DocuAssignment_9 : ( ruleDocumentation ) ;
     public final void rule__PrimitiveType__DocuAssignment_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23670:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:23671:1: ( ruleDocumentation )
+            // InternalRoom.g:23929:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23930:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23671:1: ( ruleDocumentation )
-            // InternalRoom.g:23672:1: ruleDocumentation
+            // InternalRoom.g:23930:1: ( ruleDocumentation )
+            // InternalRoom.g:23931:1: ruleDocumentation
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDocuDocumentationParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -64195,17 +64932,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__NameAssignment_1"
-    // InternalRoom.g:23681:1: rule__EnumerationType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23940:1: rule__EnumerationType__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__EnumerationType__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23685:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23686:1: ( RULE_ID )
+            // InternalRoom.g:23944:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23945:1: ( RULE_ID )
             {
-            // InternalRoom.g:23686:1: ( RULE_ID )
-            // InternalRoom.g:23687:1: RULE_ID
+            // InternalRoom.g:23945:1: ( RULE_ID )
+            // InternalRoom.g:23946:1: RULE_ID
             {
              before(grammarAccess.getEnumerationTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64232,17 +64969,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__DocuAssignment_2"
-    // InternalRoom.g:23696:1: rule__EnumerationType__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23955:1: rule__EnumerationType__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__EnumerationType__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23700:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:23701:1: ( ruleDocumentation )
+            // InternalRoom.g:23959:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23960:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23701:1: ( ruleDocumentation )
-            // InternalRoom.g:23702:1: ruleDocumentation
+            // InternalRoom.g:23960:1: ( ruleDocumentation )
+            // InternalRoom.g:23961:1: ruleDocumentation
             {
              before(grammarAccess.getEnumerationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -64273,21 +65010,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__PrimitiveTypeAssignment_3_1"
-    // InternalRoom.g:23711:1: rule__EnumerationType__PrimitiveTypeAssignment_3_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:23970:1: rule__EnumerationType__PrimitiveTypeAssignment_3_1 : ( ( ruleFQN ) ) ;
     public final void rule__EnumerationType__PrimitiveTypeAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23715:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:23716:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23974:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:23975:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23716:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23717:1: ( ruleFQN )
+            // InternalRoom.g:23975:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23976:1: ( ruleFQN )
             {
              before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeCrossReference_3_1_0()); 
-            // InternalRoom.g:23718:1: ( ruleFQN )
-            // InternalRoom.g:23719:1: ruleFQN
+            // InternalRoom.g:23977:1: ( ruleFQN )
+            // InternalRoom.g:23978:1: ruleFQN
             {
              before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -64322,17 +65059,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__LiteralsAssignment_5_0"
-    // InternalRoom.g:23730:1: rule__EnumerationType__LiteralsAssignment_5_0 : ( ruleEnumLiteral ) ;
+    // InternalRoom.g:23989:1: rule__EnumerationType__LiteralsAssignment_5_0 : ( ruleEnumLiteral ) ;
     public final void rule__EnumerationType__LiteralsAssignment_5_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23734:1: ( ( ruleEnumLiteral ) )
-            // InternalRoom.g:23735:1: ( ruleEnumLiteral )
+            // InternalRoom.g:23993:1: ( ( ruleEnumLiteral ) )
+            // InternalRoom.g:23994:1: ( ruleEnumLiteral )
             {
-            // InternalRoom.g:23735:1: ( ruleEnumLiteral )
-            // InternalRoom.g:23736:1: ruleEnumLiteral
+            // InternalRoom.g:23994:1: ( ruleEnumLiteral )
+            // InternalRoom.g:23995:1: ruleEnumLiteral
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -64363,17 +65100,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__LiteralsAssignment_5_1_1"
-    // InternalRoom.g:23745:1: rule__EnumerationType__LiteralsAssignment_5_1_1 : ( ruleEnumLiteral ) ;
+    // InternalRoom.g:24004:1: rule__EnumerationType__LiteralsAssignment_5_1_1 : ( ruleEnumLiteral ) ;
     public final void rule__EnumerationType__LiteralsAssignment_5_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23749:1: ( ( ruleEnumLiteral ) )
-            // InternalRoom.g:23750:1: ( ruleEnumLiteral )
+            // InternalRoom.g:24008:1: ( ( ruleEnumLiteral ) )
+            // InternalRoom.g:24009:1: ( ruleEnumLiteral )
             {
-            // InternalRoom.g:23750:1: ( ruleEnumLiteral )
-            // InternalRoom.g:23751:1: ruleEnumLiteral
+            // InternalRoom.g:24009:1: ( ruleEnumLiteral )
+            // InternalRoom.g:24010:1: ruleEnumLiteral
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64404,17 +65141,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__NameAssignment_0"
-    // InternalRoom.g:23760:1: rule__EnumLiteral__NameAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:24019:1: rule__EnumLiteral__NameAssignment_0 : ( RULE_ID ) ;
     public final void rule__EnumLiteral__NameAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23764:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23765:1: ( RULE_ID )
+            // InternalRoom.g:24023:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24024:1: ( RULE_ID )
             {
-            // InternalRoom.g:23765:1: ( RULE_ID )
-            // InternalRoom.g:23766:1: RULE_ID
+            // InternalRoom.g:24024:1: ( RULE_ID )
+            // InternalRoom.g:24025:1: RULE_ID
             {
              before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64441,17 +65178,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__LiteralAssignment_1_1"
-    // InternalRoom.g:23775:1: rule__EnumLiteral__LiteralAssignment_1_1 : ( ruleIntLiteral ) ;
+    // InternalRoom.g:24034:1: rule__EnumLiteral__LiteralAssignment_1_1 : ( ruleIntLiteral ) ;
     public final void rule__EnumLiteral__LiteralAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23779:1: ( ( ruleIntLiteral ) )
-            // InternalRoom.g:23780:1: ( ruleIntLiteral )
+            // InternalRoom.g:24038:1: ( ( ruleIntLiteral ) )
+            // InternalRoom.g:24039:1: ( ruleIntLiteral )
             {
-            // InternalRoom.g:23780:1: ( ruleIntLiteral )
-            // InternalRoom.g:23781:1: ruleIntLiteral
+            // InternalRoom.g:24039:1: ( ruleIntLiteral )
+            // InternalRoom.g:24040:1: ruleIntLiteral
             {
              before(grammarAccess.getEnumLiteralAccess().getLiteralIntLiteralParserRuleCall_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64482,17 +65219,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__NameAssignment_1"
-    // InternalRoom.g:23790:1: rule__ExternalType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24049:1: rule__ExternalType__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ExternalType__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23794:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23795:1: ( RULE_ID )
+            // InternalRoom.g:24053:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24054:1: ( RULE_ID )
             {
-            // InternalRoom.g:23795:1: ( RULE_ID )
-            // InternalRoom.g:23796:1: RULE_ID
+            // InternalRoom.g:24054:1: ( RULE_ID )
+            // InternalRoom.g:24055:1: RULE_ID
             {
              before(grammarAccess.getExternalTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64519,17 +65256,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__TargetNameAssignment_3"
-    // InternalRoom.g:23805:1: rule__ExternalType__TargetNameAssignment_3 : ( RULE_STRING ) ;
+    // InternalRoom.g:24064:1: rule__ExternalType__TargetNameAssignment_3 : ( RULE_STRING ) ;
     public final void rule__ExternalType__TargetNameAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23809:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:23810:1: ( RULE_STRING )
+            // InternalRoom.g:24068:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:24069:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23810:1: ( RULE_STRING )
-            // InternalRoom.g:23811:1: RULE_STRING
+            // InternalRoom.g:24069:1: ( RULE_STRING )
+            // InternalRoom.g:24070:1: RULE_STRING
             {
              before(grammarAccess.getExternalTypeAccess().getTargetNameSTRINGTerminalRuleCall_3_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64556,17 +65293,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__DefaultValueLiteralAssignment_4_1"
-    // InternalRoom.g:23820:1: rule__ExternalType__DefaultValueLiteralAssignment_4_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:24079:1: rule__ExternalType__DefaultValueLiteralAssignment_4_1 : ( RULE_STRING ) ;
     public final void rule__ExternalType__DefaultValueLiteralAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23824:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:23825:1: ( RULE_STRING )
+            // InternalRoom.g:24083:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:24084:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23825:1: ( RULE_STRING )
-            // InternalRoom.g:23826:1: RULE_STRING
+            // InternalRoom.g:24084:1: ( RULE_STRING )
+            // InternalRoom.g:24085:1: RULE_STRING
             {
              before(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64593,17 +65330,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__DocuAssignment_5"
-    // InternalRoom.g:23835:1: rule__ExternalType__DocuAssignment_5 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24094:1: rule__ExternalType__DocuAssignment_5 : ( ruleDocumentation ) ;
     public final void rule__ExternalType__DocuAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23839:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:23840:1: ( ruleDocumentation )
+            // InternalRoom.g:24098:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24099:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23840:1: ( ruleDocumentation )
-            // InternalRoom.g:23841:1: ruleDocumentation
+            // InternalRoom.g:24099:1: ( ruleDocumentation )
+            // InternalRoom.g:24100:1: ruleDocumentation
             {
              before(grammarAccess.getExternalTypeAccess().getDocuDocumentationParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -64634,17 +65371,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__NameAssignment_1"
-    // InternalRoom.g:23850:1: rule__DataClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24109:1: rule__DataClass__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__DataClass__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23854:1: ( ( RULE_ID ) )
-            // InternalRoom.g:23855:1: ( RULE_ID )
+            // InternalRoom.g:24113:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24114:1: ( RULE_ID )
             {
-            // InternalRoom.g:23855:1: ( RULE_ID )
-            // InternalRoom.g:23856:1: RULE_ID
+            // InternalRoom.g:24114:1: ( RULE_ID )
+            // InternalRoom.g:24115:1: RULE_ID
             {
              before(grammarAccess.getDataClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64671,17 +65408,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__DocuAssignment_2"
-    // InternalRoom.g:23865:1: rule__DataClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24124:1: rule__DataClass__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__DataClass__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23869:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:23870:1: ( ruleDocumentation )
+            // InternalRoom.g:24128:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24129:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23870:1: ( ruleDocumentation )
-            // InternalRoom.g:23871:1: ruleDocumentation
+            // InternalRoom.g:24129:1: ( ruleDocumentation )
+            // InternalRoom.g:24130:1: ruleDocumentation
             {
              before(grammarAccess.getDataClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -64712,21 +65449,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__BaseAssignment_3_1"
-    // InternalRoom.g:23880:1: rule__DataClass__BaseAssignment_3_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:24139:1: rule__DataClass__BaseAssignment_3_1 : ( ( ruleFQN ) ) ;
     public final void rule__DataClass__BaseAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23884:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:23885:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24143:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24144:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23885:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23886:1: ( ruleFQN )
+            // InternalRoom.g:24144:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24145:1: ( ruleFQN )
             {
              before(grammarAccess.getDataClassAccess().getBaseDataClassCrossReference_3_1_0()); 
-            // InternalRoom.g:23887:1: ( ruleFQN )
-            // InternalRoom.g:23888:1: ruleFQN
+            // InternalRoom.g:24146:1: ( ruleFQN )
+            // InternalRoom.g:24147:1: ruleFQN
             {
              before(grammarAccess.getDataClassAccess().getBaseDataClassFQNParserRuleCall_3_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -64761,17 +65498,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__AnnotationsAssignment_5"
-    // InternalRoom.g:23899:1: rule__DataClass__AnnotationsAssignment_5 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24158:1: rule__DataClass__AnnotationsAssignment_5 : ( ruleAnnotation ) ;
     public final void rule__DataClass__AnnotationsAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23903:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:23904:1: ( ruleAnnotation )
+            // InternalRoom.g:24162:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24163:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:23904:1: ( ruleAnnotation )
-            // InternalRoom.g:23905:1: ruleAnnotation
+            // InternalRoom.g:24163:1: ( ruleAnnotation )
+            // InternalRoom.g:24164:1: ruleAnnotation
             {
              before(grammarAccess.getDataClassAccess().getAnnotationsAnnotationParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -64802,17 +65539,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__UserCode1Assignment_6_1"
-    // InternalRoom.g:23914:1: rule__DataClass__UserCode1Assignment_6_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24173:1: rule__DataClass__UserCode1Assignment_6_1 : ( ruleDetailCode ) ;
     public final void rule__DataClass__UserCode1Assignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23918:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:23919:1: ( ruleDetailCode )
+            // InternalRoom.g:24177:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24178:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23919:1: ( ruleDetailCode )
-            // InternalRoom.g:23920:1: ruleDetailCode
+            // InternalRoom.g:24178:1: ( ruleDetailCode )
+            // InternalRoom.g:24179:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode1DetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64843,17 +65580,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__UserCode2Assignment_7_1"
-    // InternalRoom.g:23929:1: rule__DataClass__UserCode2Assignment_7_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24188:1: rule__DataClass__UserCode2Assignment_7_1 : ( ruleDetailCode ) ;
     public final void rule__DataClass__UserCode2Assignment_7_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23933:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:23934:1: ( ruleDetailCode )
+            // InternalRoom.g:24192:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24193:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23934:1: ( ruleDetailCode )
-            // InternalRoom.g:23935:1: ruleDetailCode
+            // InternalRoom.g:24193:1: ( ruleDetailCode )
+            // InternalRoom.g:24194:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode2DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64884,17 +65621,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__UserCode3Assignment_8_1"
-    // InternalRoom.g:23944:1: rule__DataClass__UserCode3Assignment_8_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24203:1: rule__DataClass__UserCode3Assignment_8_1 : ( ruleDetailCode ) ;
     public final void rule__DataClass__UserCode3Assignment_8_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23948:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:23949:1: ( ruleDetailCode )
+            // InternalRoom.g:24207:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24208:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23949:1: ( ruleDetailCode )
-            // InternalRoom.g:23950:1: ruleDetailCode
+            // InternalRoom.g:24208:1: ( ruleDetailCode )
+            // InternalRoom.g:24209:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode3DetailCodeParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64925,17 +65662,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__OperationsAssignment_9_0"
-    // InternalRoom.g:23959:1: rule__DataClass__OperationsAssignment_9_0 : ( ruleStandardOperation ) ;
+    // InternalRoom.g:24218:1: rule__DataClass__OperationsAssignment_9_0 : ( ruleStandardOperation ) ;
     public final void rule__DataClass__OperationsAssignment_9_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23963:1: ( ( ruleStandardOperation ) )
-            // InternalRoom.g:23964:1: ( ruleStandardOperation )
+            // InternalRoom.g:24222:1: ( ( ruleStandardOperation ) )
+            // InternalRoom.g:24223:1: ( ruleStandardOperation )
             {
-            // InternalRoom.g:23964:1: ( ruleStandardOperation )
-            // InternalRoom.g:23965:1: ruleStandardOperation
+            // InternalRoom.g:24223:1: ( ruleStandardOperation )
+            // InternalRoom.g:24224:1: ruleStandardOperation
             {
              before(grammarAccess.getDataClassAccess().getOperationsStandardOperationParserRuleCall_9_0_0()); 
             pushFollow(FOLLOW_2);
@@ -64966,17 +65703,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__StructorsAssignment_9_1"
-    // InternalRoom.g:23974:1: rule__DataClass__StructorsAssignment_9_1 : ( ruleClassStructor ) ;
+    // InternalRoom.g:24233:1: rule__DataClass__StructorsAssignment_9_1 : ( ruleClassStructor ) ;
     public final void rule__DataClass__StructorsAssignment_9_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23978:1: ( ( ruleClassStructor ) )
-            // InternalRoom.g:23979:1: ( ruleClassStructor )
+            // InternalRoom.g:24237:1: ( ( ruleClassStructor ) )
+            // InternalRoom.g:24238:1: ( ruleClassStructor )
             {
-            // InternalRoom.g:23979:1: ( ruleClassStructor )
-            // InternalRoom.g:23980:1: ruleClassStructor
+            // InternalRoom.g:24238:1: ( ruleClassStructor )
+            // InternalRoom.g:24239:1: ruleClassStructor
             {
              before(grammarAccess.getDataClassAccess().getStructorsClassStructorParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65007,17 +65744,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__AttributesAssignment_9_2"
-    // InternalRoom.g:23989:1: rule__DataClass__AttributesAssignment_9_2 : ( ruleAttribute ) ;
+    // InternalRoom.g:24248:1: rule__DataClass__AttributesAssignment_9_2 : ( ruleAttribute ) ;
     public final void rule__DataClass__AttributesAssignment_9_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:23993:1: ( ( ruleAttribute ) )
-            // InternalRoom.g:23994:1: ( ruleAttribute )
+            // InternalRoom.g:24252:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:24253:1: ( ruleAttribute )
             {
-            // InternalRoom.g:23994:1: ( ruleAttribute )
-            // InternalRoom.g:23995:1: ruleAttribute
+            // InternalRoom.g:24253:1: ( ruleAttribute )
+            // InternalRoom.g:24254:1: ruleAttribute
             {
              before(grammarAccess.getDataClassAccess().getAttributesAttributeParserRuleCall_9_2_0()); 
             pushFollow(FOLLOW_2);
@@ -65048,17 +65785,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__NameAssignment_1"
-    // InternalRoom.g:24004:1: rule__Attribute__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24263:1: rule__Attribute__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__Attribute__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24008:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24009:1: ( RULE_ID )
+            // InternalRoom.g:24267:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24268:1: ( RULE_ID )
             {
-            // InternalRoom.g:24009:1: ( RULE_ID )
-            // InternalRoom.g:24010:1: RULE_ID
+            // InternalRoom.g:24268:1: ( RULE_ID )
+            // InternalRoom.g:24269:1: RULE_ID
             {
              before(grammarAccess.getAttributeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65085,17 +65822,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__SizeAssignment_2_1"
-    // InternalRoom.g:24019:1: rule__Attribute__SizeAssignment_2_1 : ( RULE_INT ) ;
+    // InternalRoom.g:24278:1: rule__Attribute__SizeAssignment_2_1 : ( RULE_INT ) ;
     public final void rule__Attribute__SizeAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24023:1: ( ( RULE_INT ) )
-            // InternalRoom.g:24024:1: ( RULE_INT )
+            // InternalRoom.g:24282:1: ( ( RULE_INT ) )
+            // InternalRoom.g:24283:1: ( RULE_INT )
             {
-            // InternalRoom.g:24024:1: ( RULE_INT )
-            // InternalRoom.g:24025:1: RULE_INT
+            // InternalRoom.g:24283:1: ( RULE_INT )
+            // InternalRoom.g:24284:1: RULE_INT
             {
              before(grammarAccess.getAttributeAccess().getSizeINTTerminalRuleCall_2_1_0()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -65122,17 +65859,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__TypeAssignment_4"
-    // InternalRoom.g:24034:1: rule__Attribute__TypeAssignment_4 : ( ruleRefableType ) ;
+    // InternalRoom.g:24293:1: rule__Attribute__TypeAssignment_4 : ( ruleRefableType ) ;
     public final void rule__Attribute__TypeAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24038:1: ( ( ruleRefableType ) )
-            // InternalRoom.g:24039:1: ( ruleRefableType )
+            // InternalRoom.g:24297:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24298:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24039:1: ( ruleRefableType )
-            // InternalRoom.g:24040:1: ruleRefableType
+            // InternalRoom.g:24298:1: ( ruleRefableType )
+            // InternalRoom.g:24299:1: ruleRefableType
             {
              before(grammarAccess.getAttributeAccess().getTypeRefableTypeParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -65163,17 +65900,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__DefaultValueLiteralAssignment_5_1"
-    // InternalRoom.g:24049:1: rule__Attribute__DefaultValueLiteralAssignment_5_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:24308:1: rule__Attribute__DefaultValueLiteralAssignment_5_1 : ( RULE_STRING ) ;
     public final void rule__Attribute__DefaultValueLiteralAssignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24053:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:24054:1: ( RULE_STRING )
+            // InternalRoom.g:24312:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:24313:1: ( RULE_STRING )
             {
-            // InternalRoom.g:24054:1: ( RULE_STRING )
-            // InternalRoom.g:24055:1: RULE_STRING
+            // InternalRoom.g:24313:1: ( RULE_STRING )
+            // InternalRoom.g:24314:1: RULE_STRING
             {
              before(grammarAccess.getAttributeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -65200,17 +65937,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__DocuAssignment_6"
-    // InternalRoom.g:24064:1: rule__Attribute__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24323:1: rule__Attribute__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__Attribute__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24068:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24069:1: ( ruleDocumentation )
+            // InternalRoom.g:24327:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24328:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24069:1: ( ruleDocumentation )
-            // InternalRoom.g:24070:1: ruleDocumentation
+            // InternalRoom.g:24328:1: ( ruleDocumentation )
+            // InternalRoom.g:24329:1: ruleDocumentation
             {
              before(grammarAccess.getAttributeAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -65241,21 +65978,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__OverrideAssignment_0"
-    // InternalRoom.g:24079:1: rule__StandardOperation__OverrideAssignment_0 : ( ( 'override' ) ) ;
+    // InternalRoom.g:24338:1: rule__StandardOperation__OverrideAssignment_0 : ( ( 'override' ) ) ;
     public final void rule__StandardOperation__OverrideAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24083:1: ( ( ( 'override' ) ) )
-            // InternalRoom.g:24084:1: ( ( 'override' ) )
+            // InternalRoom.g:24342:1: ( ( ( 'override' ) ) )
+            // InternalRoom.g:24343:1: ( ( 'override' ) )
             {
-            // InternalRoom.g:24084:1: ( ( 'override' ) )
-            // InternalRoom.g:24085:1: ( 'override' )
+            // InternalRoom.g:24343:1: ( ( 'override' ) )
+            // InternalRoom.g:24344:1: ( 'override' )
             {
              before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); 
-            // InternalRoom.g:24086:1: ( 'override' )
-            // InternalRoom.g:24087:1: 'override'
+            // InternalRoom.g:24345:1: ( 'override' )
+            // InternalRoom.g:24346:1: 'override'
             {
              before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); 
             match(input,128,FOLLOW_2); 
@@ -65286,17 +66023,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__NameAssignment_2"
-    // InternalRoom.g:24102:1: rule__StandardOperation__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24361:1: rule__StandardOperation__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__StandardOperation__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24106:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24107:1: ( RULE_ID )
+            // InternalRoom.g:24365:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24366:1: ( RULE_ID )
             {
-            // InternalRoom.g:24107:1: ( RULE_ID )
-            // InternalRoom.g:24108:1: RULE_ID
+            // InternalRoom.g:24366:1: ( RULE_ID )
+            // InternalRoom.g:24367:1: RULE_ID
             {
              before(grammarAccess.getStandardOperationAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65323,17 +66060,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__ArgumentsAssignment_4_0"
-    // InternalRoom.g:24117:1: rule__StandardOperation__ArgumentsAssignment_4_0 : ( ruleVarDecl ) ;
+    // InternalRoom.g:24376:1: rule__StandardOperation__ArgumentsAssignment_4_0 : ( ruleVarDecl ) ;
     public final void rule__StandardOperation__ArgumentsAssignment_4_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24121:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24122:1: ( ruleVarDecl )
+            // InternalRoom.g:24380:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24381:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24122:1: ( ruleVarDecl )
-            // InternalRoom.g:24123:1: ruleVarDecl
+            // InternalRoom.g:24381:1: ( ruleVarDecl )
+            // InternalRoom.g:24382:1: ruleVarDecl
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65364,17 +66101,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__ArgumentsAssignment_4_1_1"
-    // InternalRoom.g:24132:1: rule__StandardOperation__ArgumentsAssignment_4_1_1 : ( ruleVarDecl ) ;
+    // InternalRoom.g:24391:1: rule__StandardOperation__ArgumentsAssignment_4_1_1 : ( ruleVarDecl ) ;
     public final void rule__StandardOperation__ArgumentsAssignment_4_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24136:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24137:1: ( ruleVarDecl )
+            // InternalRoom.g:24395:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24396:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24137:1: ( ruleVarDecl )
-            // InternalRoom.g:24138:1: ruleVarDecl
+            // InternalRoom.g:24396:1: ( ruleVarDecl )
+            // InternalRoom.g:24397:1: ruleVarDecl
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65405,17 +66142,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__ReturnTypeAssignment_6_1_1"
-    // InternalRoom.g:24147:1: rule__StandardOperation__ReturnTypeAssignment_6_1_1 : ( ruleRefableType ) ;
+    // InternalRoom.g:24406:1: rule__StandardOperation__ReturnTypeAssignment_6_1_1 : ( ruleRefableType ) ;
     public final void rule__StandardOperation__ReturnTypeAssignment_6_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24151:1: ( ( ruleRefableType ) )
-            // InternalRoom.g:24152:1: ( ruleRefableType )
+            // InternalRoom.g:24410:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24411:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24152:1: ( ruleRefableType )
-            // InternalRoom.g:24153:1: ruleRefableType
+            // InternalRoom.g:24411:1: ( ruleRefableType )
+            // InternalRoom.g:24412:1: ruleRefableType
             {
              before(grammarAccess.getStandardOperationAccess().getReturnTypeRefableTypeParserRuleCall_6_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65446,17 +66183,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__DocuAssignment_7"
-    // InternalRoom.g:24162:1: rule__StandardOperation__DocuAssignment_7 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24421:1: rule__StandardOperation__DocuAssignment_7 : ( ruleDocumentation ) ;
     public final void rule__StandardOperation__DocuAssignment_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24166:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24167:1: ( ruleDocumentation )
+            // InternalRoom.g:24425:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24426:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24167:1: ( ruleDocumentation )
-            // InternalRoom.g:24168:1: ruleDocumentation
+            // InternalRoom.g:24426:1: ( ruleDocumentation )
+            // InternalRoom.g:24427:1: ruleDocumentation
             {
              before(grammarAccess.getStandardOperationAccess().getDocuDocumentationParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -65487,17 +66224,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__DetailCodeAssignment_8"
-    // InternalRoom.g:24177:1: rule__StandardOperation__DetailCodeAssignment_8 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24436:1: rule__StandardOperation__DetailCodeAssignment_8 : ( ruleDetailCode ) ;
     public final void rule__StandardOperation__DetailCodeAssignment_8() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24181:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24182:1: ( ruleDetailCode )
+            // InternalRoom.g:24440:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24441:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24182:1: ( ruleDetailCode )
-            // InternalRoom.g:24183:1: ruleDetailCode
+            // InternalRoom.g:24441:1: ( ruleDetailCode )
+            // InternalRoom.g:24442:1: ruleDetailCode
             {
              before(grammarAccess.getStandardOperationAccess().getDetailCodeDetailCodeParserRuleCall_8_0()); 
             pushFollow(FOLLOW_2);
@@ -65528,17 +66265,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__NameAssignment_1"
-    // InternalRoom.g:24192:1: rule__PortOperation__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24451:1: rule__PortOperation__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__PortOperation__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24196:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24197:1: ( RULE_ID )
+            // InternalRoom.g:24455:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24456:1: ( RULE_ID )
             {
-            // InternalRoom.g:24197:1: ( RULE_ID )
-            // InternalRoom.g:24198:1: RULE_ID
+            // InternalRoom.g:24456:1: ( RULE_ID )
+            // InternalRoom.g:24457:1: RULE_ID
             {
              before(grammarAccess.getPortOperationAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65565,17 +66302,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__ArgumentsAssignment_3_0"
-    // InternalRoom.g:24207:1: rule__PortOperation__ArgumentsAssignment_3_0 : ( ruleVarDecl ) ;
+    // InternalRoom.g:24466:1: rule__PortOperation__ArgumentsAssignment_3_0 : ( ruleVarDecl ) ;
     public final void rule__PortOperation__ArgumentsAssignment_3_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24211:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24212:1: ( ruleVarDecl )
+            // InternalRoom.g:24470:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24471:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24212:1: ( ruleVarDecl )
-            // InternalRoom.g:24213:1: ruleVarDecl
+            // InternalRoom.g:24471:1: ( ruleVarDecl )
+            // InternalRoom.g:24472:1: ruleVarDecl
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65606,17 +66343,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__ArgumentsAssignment_3_1_1"
-    // InternalRoom.g:24222:1: rule__PortOperation__ArgumentsAssignment_3_1_1 : ( ruleVarDecl ) ;
+    // InternalRoom.g:24481:1: rule__PortOperation__ArgumentsAssignment_3_1_1 : ( ruleVarDecl ) ;
     public final void rule__PortOperation__ArgumentsAssignment_3_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24226:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24227:1: ( ruleVarDecl )
+            // InternalRoom.g:24485:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24486:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24227:1: ( ruleVarDecl )
-            // InternalRoom.g:24228:1: ruleVarDecl
+            // InternalRoom.g:24486:1: ( ruleVarDecl )
+            // InternalRoom.g:24487:1: ruleVarDecl
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65647,17 +66384,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__ReturnTypeAssignment_5_0_1_1"
-    // InternalRoom.g:24237:1: rule__PortOperation__ReturnTypeAssignment_5_0_1_1 : ( ruleRefableType ) ;
+    // InternalRoom.g:24496:1: rule__PortOperation__ReturnTypeAssignment_5_0_1_1 : ( ruleRefableType ) ;
     public final void rule__PortOperation__ReturnTypeAssignment_5_0_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24241:1: ( ( ruleRefableType ) )
-            // InternalRoom.g:24242:1: ( ruleRefableType )
+            // InternalRoom.g:24500:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24501:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24242:1: ( ruleRefableType )
-            // InternalRoom.g:24243:1: ruleRefableType
+            // InternalRoom.g:24501:1: ( ruleRefableType )
+            // InternalRoom.g:24502:1: ruleRefableType
             {
              before(grammarAccess.getPortOperationAccess().getReturnTypeRefableTypeParserRuleCall_5_0_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65688,21 +66425,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__SendsMsgAssignment_5_1_1"
-    // InternalRoom.g:24252:1: rule__PortOperation__SendsMsgAssignment_5_1_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:24511:1: rule__PortOperation__SendsMsgAssignment_5_1_1 : ( ( RULE_ID ) ) ;
     public final void rule__PortOperation__SendsMsgAssignment_5_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24256:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:24257:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24515:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:24516:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24257:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24258:1: ( RULE_ID )
+            // InternalRoom.g:24516:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24517:1: ( RULE_ID )
             {
              before(grammarAccess.getPortOperationAccess().getSendsMsgMessageCrossReference_5_1_1_0()); 
-            // InternalRoom.g:24259:1: ( RULE_ID )
-            // InternalRoom.g:24260:1: RULE_ID
+            // InternalRoom.g:24518:1: ( RULE_ID )
+            // InternalRoom.g:24519:1: RULE_ID
             {
              before(grammarAccess.getPortOperationAccess().getSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65733,17 +66470,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__DocuAssignment_6"
-    // InternalRoom.g:24271:1: rule__PortOperation__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24530:1: rule__PortOperation__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__PortOperation__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24275:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24276:1: ( ruleDocumentation )
+            // InternalRoom.g:24534:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24535:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24276:1: ( ruleDocumentation )
-            // InternalRoom.g:24277:1: ruleDocumentation
+            // InternalRoom.g:24535:1: ( ruleDocumentation )
+            // InternalRoom.g:24536:1: ruleDocumentation
             {
              before(grammarAccess.getPortOperationAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -65774,17 +66511,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__DetailCodeAssignment_7"
-    // InternalRoom.g:24286:1: rule__PortOperation__DetailCodeAssignment_7 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24545:1: rule__PortOperation__DetailCodeAssignment_7 : ( ruleDetailCode ) ;
     public final void rule__PortOperation__DetailCodeAssignment_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24290:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24291:1: ( ruleDetailCode )
+            // InternalRoom.g:24549:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24550:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24291:1: ( ruleDetailCode )
-            // InternalRoom.g:24292:1: ruleDetailCode
+            // InternalRoom.g:24550:1: ( ruleDetailCode )
+            // InternalRoom.g:24551:1: ruleDetailCode
             {
              before(grammarAccess.getPortOperationAccess().getDetailCodeDetailCodeParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -65815,21 +66552,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__NameAssignment_0"
-    // InternalRoom.g:24301:1: rule__ClassStructor__NameAssignment_0 : ( ( rule__ClassStructor__NameAlternatives_0_0 ) ) ;
+    // InternalRoom.g:24560:1: rule__ClassStructor__NameAssignment_0 : ( ( rule__ClassStructor__NameAlternatives_0_0 ) ) ;
     public final void rule__ClassStructor__NameAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24305:1: ( ( ( rule__ClassStructor__NameAlternatives_0_0 ) ) )
-            // InternalRoom.g:24306:1: ( ( rule__ClassStructor__NameAlternatives_0_0 ) )
+            // InternalRoom.g:24564:1: ( ( ( rule__ClassStructor__NameAlternatives_0_0 ) ) )
+            // InternalRoom.g:24565:1: ( ( rule__ClassStructor__NameAlternatives_0_0 ) )
             {
-            // InternalRoom.g:24306:1: ( ( rule__ClassStructor__NameAlternatives_0_0 ) )
-            // InternalRoom.g:24307:1: ( rule__ClassStructor__NameAlternatives_0_0 )
+            // InternalRoom.g:24565:1: ( ( rule__ClassStructor__NameAlternatives_0_0 ) )
+            // InternalRoom.g:24566:1: ( rule__ClassStructor__NameAlternatives_0_0 )
             {
              before(grammarAccess.getClassStructorAccess().getNameAlternatives_0_0()); 
-            // InternalRoom.g:24308:1: ( rule__ClassStructor__NameAlternatives_0_0 )
-            // InternalRoom.g:24308:2: rule__ClassStructor__NameAlternatives_0_0
+            // InternalRoom.g:24567:1: ( rule__ClassStructor__NameAlternatives_0_0 )
+            // InternalRoom.g:24567:2: rule__ClassStructor__NameAlternatives_0_0
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__NameAlternatives_0_0();
@@ -65862,17 +66599,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__DetailCodeAssignment_1"
-    // InternalRoom.g:24317:1: rule__ClassStructor__DetailCodeAssignment_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24576:1: rule__ClassStructor__DetailCodeAssignment_1 : ( ruleDetailCode ) ;
     public final void rule__ClassStructor__DetailCodeAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24321:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24322:1: ( ruleDetailCode )
+            // InternalRoom.g:24580:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24581:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24322:1: ( ruleDetailCode )
-            // InternalRoom.g:24323:1: ruleDetailCode
+            // InternalRoom.g:24581:1: ( ruleDetailCode )
+            // InternalRoom.g:24582:1: ruleDetailCode
             {
              before(grammarAccess.getClassStructorAccess().getDetailCodeDetailCodeParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65903,17 +66640,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__CommTypeAssignment_0"
-    // InternalRoom.g:24332:1: rule__ProtocolClass__CommTypeAssignment_0 : ( ruleCommunicationType ) ;
+    // InternalRoom.g:24591:1: rule__ProtocolClass__CommTypeAssignment_0 : ( ruleCommunicationType ) ;
     public final void rule__ProtocolClass__CommTypeAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24336:1: ( ( ruleCommunicationType ) )
-            // InternalRoom.g:24337:1: ( ruleCommunicationType )
+            // InternalRoom.g:24595:1: ( ( ruleCommunicationType ) )
+            // InternalRoom.g:24596:1: ( ruleCommunicationType )
             {
-            // InternalRoom.g:24337:1: ( ruleCommunicationType )
-            // InternalRoom.g:24338:1: ruleCommunicationType
+            // InternalRoom.g:24596:1: ( ruleCommunicationType )
+            // InternalRoom.g:24597:1: ruleCommunicationType
             {
              before(grammarAccess.getProtocolClassAccess().getCommTypeCommunicationTypeEnumRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65944,17 +66681,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__NameAssignment_2"
-    // InternalRoom.g:24347:1: rule__ProtocolClass__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24606:1: rule__ProtocolClass__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__ProtocolClass__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24351:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24352:1: ( RULE_ID )
+            // InternalRoom.g:24610:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24611:1: ( RULE_ID )
             {
-            // InternalRoom.g:24352:1: ( RULE_ID )
-            // InternalRoom.g:24353:1: RULE_ID
+            // InternalRoom.g:24611:1: ( RULE_ID )
+            // InternalRoom.g:24612:1: RULE_ID
             {
              before(grammarAccess.getProtocolClassAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65981,17 +66718,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__DocuAssignment_3"
-    // InternalRoom.g:24362:1: rule__ProtocolClass__DocuAssignment_3 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24621:1: rule__ProtocolClass__DocuAssignment_3 : ( ruleDocumentation ) ;
     public final void rule__ProtocolClass__DocuAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24366:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24367:1: ( ruleDocumentation )
+            // InternalRoom.g:24625:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24626:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24367:1: ( ruleDocumentation )
-            // InternalRoom.g:24368:1: ruleDocumentation
+            // InternalRoom.g:24626:1: ( ruleDocumentation )
+            // InternalRoom.g:24627:1: ruleDocumentation
             {
              before(grammarAccess.getProtocolClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -66022,21 +66759,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__BaseAssignment_4_1"
-    // InternalRoom.g:24377:1: rule__ProtocolClass__BaseAssignment_4_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:24636:1: rule__ProtocolClass__BaseAssignment_4_1 : ( ( ruleFQN ) ) ;
     public final void rule__ProtocolClass__BaseAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24381:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:24382:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24640:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24641:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24382:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24383:1: ( ruleFQN )
+            // InternalRoom.g:24641:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24642:1: ( ruleFQN )
             {
              before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassCrossReference_4_1_0()); 
-            // InternalRoom.g:24384:1: ( ruleFQN )
-            // InternalRoom.g:24385:1: ruleFQN
+            // InternalRoom.g:24643:1: ( ruleFQN )
+            // InternalRoom.g:24644:1: ruleFQN
             {
              before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassFQNParserRuleCall_4_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -66071,17 +66808,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__AnnotationsAssignment_6"
-    // InternalRoom.g:24396:1: rule__ProtocolClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24655:1: rule__ProtocolClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
     public final void rule__ProtocolClass__AnnotationsAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24400:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:24401:1: ( ruleAnnotation )
+            // InternalRoom.g:24659:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24660:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24401:1: ( ruleAnnotation )
-            // InternalRoom.g:24402:1: ruleAnnotation
+            // InternalRoom.g:24660:1: ( ruleAnnotation )
+            // InternalRoom.g:24661:1: ruleAnnotation
             {
              before(grammarAccess.getProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -66112,17 +66849,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__UserCode1Assignment_7_1"
-    // InternalRoom.g:24411:1: rule__ProtocolClass__UserCode1Assignment_7_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24670:1: rule__ProtocolClass__UserCode1Assignment_7_1 : ( ruleDetailCode ) ;
     public final void rule__ProtocolClass__UserCode1Assignment_7_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24415:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24416:1: ( ruleDetailCode )
+            // InternalRoom.g:24674:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24675:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24416:1: ( ruleDetailCode )
-            // InternalRoom.g:24417:1: ruleDetailCode
+            // InternalRoom.g:24675:1: ( ruleDetailCode )
+            // InternalRoom.g:24676:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode1DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66153,17 +66890,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__UserCode2Assignment_8_1"
-    // InternalRoom.g:24426:1: rule__ProtocolClass__UserCode2Assignment_8_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24685:1: rule__ProtocolClass__UserCode2Assignment_8_1 : ( ruleDetailCode ) ;
     public final void rule__ProtocolClass__UserCode2Assignment_8_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24430:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24431:1: ( ruleDetailCode )
+            // InternalRoom.g:24689:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24690:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24431:1: ( ruleDetailCode )
-            // InternalRoom.g:24432:1: ruleDetailCode
+            // InternalRoom.g:24690:1: ( ruleDetailCode )
+            // InternalRoom.g:24691:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode2DetailCodeParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66194,17 +66931,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__UserCode3Assignment_9_1"
-    // InternalRoom.g:24441:1: rule__ProtocolClass__UserCode3Assignment_9_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24700:1: rule__ProtocolClass__UserCode3Assignment_9_1 : ( ruleDetailCode ) ;
     public final void rule__ProtocolClass__UserCode3Assignment_9_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24445:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24446:1: ( ruleDetailCode )
+            // InternalRoom.g:24704:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24705:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24446:1: ( ruleDetailCode )
-            // InternalRoom.g:24447:1: ruleDetailCode
+            // InternalRoom.g:24705:1: ( ruleDetailCode )
+            // InternalRoom.g:24706:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode3DetailCodeParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66235,17 +66972,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__IncomingMessagesAssignment_10_2"
-    // InternalRoom.g:24456:1: rule__ProtocolClass__IncomingMessagesAssignment_10_2 : ( ruleMessage ) ;
+    // InternalRoom.g:24715:1: rule__ProtocolClass__IncomingMessagesAssignment_10_2 : ( ruleMessage ) ;
     public final void rule__ProtocolClass__IncomingMessagesAssignment_10_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24460:1: ( ( ruleMessage ) )
-            // InternalRoom.g:24461:1: ( ruleMessage )
+            // InternalRoom.g:24719:1: ( ( ruleMessage ) )
+            // InternalRoom.g:24720:1: ( ruleMessage )
             {
-            // InternalRoom.g:24461:1: ( ruleMessage )
-            // InternalRoom.g:24462:1: ruleMessage
+            // InternalRoom.g:24720:1: ( ruleMessage )
+            // InternalRoom.g:24721:1: ruleMessage
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingMessagesMessageParserRuleCall_10_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66276,17 +67013,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__OutgoingMessagesAssignment_11_2"
-    // InternalRoom.g:24471:1: rule__ProtocolClass__OutgoingMessagesAssignment_11_2 : ( ruleMessage ) ;
+    // InternalRoom.g:24730:1: rule__ProtocolClass__OutgoingMessagesAssignment_11_2 : ( ruleMessage ) ;
     public final void rule__ProtocolClass__OutgoingMessagesAssignment_11_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24475:1: ( ( ruleMessage ) )
-            // InternalRoom.g:24476:1: ( ruleMessage )
+            // InternalRoom.g:24734:1: ( ( ruleMessage ) )
+            // InternalRoom.g:24735:1: ( ruleMessage )
             {
-            // InternalRoom.g:24476:1: ( ruleMessage )
-            // InternalRoom.g:24477:1: ruleMessage
+            // InternalRoom.g:24735:1: ( ruleMessage )
+            // InternalRoom.g:24736:1: ruleMessage
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesMessageParserRuleCall_11_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66317,17 +67054,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__RegularAssignment_12_2"
-    // InternalRoom.g:24486:1: rule__ProtocolClass__RegularAssignment_12_2 : ( rulePortClass ) ;
+    // InternalRoom.g:24745:1: rule__ProtocolClass__RegularAssignment_12_2 : ( rulePortClass ) ;
     public final void rule__ProtocolClass__RegularAssignment_12_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24490:1: ( ( rulePortClass ) )
-            // InternalRoom.g:24491:1: ( rulePortClass )
+            // InternalRoom.g:24749:1: ( ( rulePortClass ) )
+            // InternalRoom.g:24750:1: ( rulePortClass )
             {
-            // InternalRoom.g:24491:1: ( rulePortClass )
-            // InternalRoom.g:24492:1: rulePortClass
+            // InternalRoom.g:24750:1: ( rulePortClass )
+            // InternalRoom.g:24751:1: rulePortClass
             {
              before(grammarAccess.getProtocolClassAccess().getRegularPortClassParserRuleCall_12_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66358,17 +67095,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__ConjugatedAssignment_13_2"
-    // InternalRoom.g:24501:1: rule__ProtocolClass__ConjugatedAssignment_13_2 : ( rulePortClass ) ;
+    // InternalRoom.g:24760:1: rule__ProtocolClass__ConjugatedAssignment_13_2 : ( rulePortClass ) ;
     public final void rule__ProtocolClass__ConjugatedAssignment_13_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24505:1: ( ( rulePortClass ) )
-            // InternalRoom.g:24506:1: ( rulePortClass )
+            // InternalRoom.g:24764:1: ( ( rulePortClass ) )
+            // InternalRoom.g:24765:1: ( rulePortClass )
             {
-            // InternalRoom.g:24506:1: ( rulePortClass )
-            // InternalRoom.g:24507:1: rulePortClass
+            // InternalRoom.g:24765:1: ( rulePortClass )
+            // InternalRoom.g:24766:1: rulePortClass
             {
              before(grammarAccess.getProtocolClassAccess().getConjugatedPortClassParserRuleCall_13_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66399,17 +67136,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__SemanticsAssignment_14"
-    // InternalRoom.g:24516:1: rule__ProtocolClass__SemanticsAssignment_14 : ( ruleProtocolSemantics ) ;
+    // InternalRoom.g:24775:1: rule__ProtocolClass__SemanticsAssignment_14 : ( ruleProtocolSemantics ) ;
     public final void rule__ProtocolClass__SemanticsAssignment_14() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24520:1: ( ( ruleProtocolSemantics ) )
-            // InternalRoom.g:24521:1: ( ruleProtocolSemantics )
+            // InternalRoom.g:24779:1: ( ( ruleProtocolSemantics ) )
+            // InternalRoom.g:24780:1: ( ruleProtocolSemantics )
             {
-            // InternalRoom.g:24521:1: ( ruleProtocolSemantics )
-            // InternalRoom.g:24522:1: ruleProtocolSemantics
+            // InternalRoom.g:24780:1: ( ruleProtocolSemantics )
+            // InternalRoom.g:24781:1: ruleProtocolSemantics
             {
              before(grammarAccess.getProtocolClassAccess().getSemanticsProtocolSemanticsParserRuleCall_14_0()); 
             pushFollow(FOLLOW_2);
@@ -66440,17 +67177,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__NameAssignment_1"
-    // InternalRoom.g:24531:1: rule__CompoundProtocolClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24790:1: rule__CompoundProtocolClass__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__CompoundProtocolClass__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24535:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24536:1: ( RULE_ID )
+            // InternalRoom.g:24794:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24795:1: ( RULE_ID )
             {
-            // InternalRoom.g:24536:1: ( RULE_ID )
-            // InternalRoom.g:24537:1: RULE_ID
+            // InternalRoom.g:24795:1: ( RULE_ID )
+            // InternalRoom.g:24796:1: RULE_ID
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66477,17 +67214,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__DocuAssignment_2"
-    // InternalRoom.g:24546:1: rule__CompoundProtocolClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24805:1: rule__CompoundProtocolClass__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__CompoundProtocolClass__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24550:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24551:1: ( ruleDocumentation )
+            // InternalRoom.g:24809:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24810:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24551:1: ( ruleDocumentation )
-            // InternalRoom.g:24552:1: ruleDocumentation
+            // InternalRoom.g:24810:1: ( ruleDocumentation )
+            // InternalRoom.g:24811:1: ruleDocumentation
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66518,17 +67255,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__AnnotationsAssignment_4"
-    // InternalRoom.g:24561:1: rule__CompoundProtocolClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24820:1: rule__CompoundProtocolClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
     public final void rule__CompoundProtocolClass__AnnotationsAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24565:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:24566:1: ( ruleAnnotation )
+            // InternalRoom.g:24824:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24825:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24566:1: ( ruleAnnotation )
-            // InternalRoom.g:24567:1: ruleAnnotation
+            // InternalRoom.g:24825:1: ( ruleAnnotation )
+            // InternalRoom.g:24826:1: ruleAnnotation
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -66559,17 +67296,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__SubProtocolsAssignment_5"
-    // InternalRoom.g:24576:1: rule__CompoundProtocolClass__SubProtocolsAssignment_5 : ( ruleSubProtocol ) ;
+    // InternalRoom.g:24835:1: rule__CompoundProtocolClass__SubProtocolsAssignment_5 : ( ruleSubProtocol ) ;
     public final void rule__CompoundProtocolClass__SubProtocolsAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24580:1: ( ( ruleSubProtocol ) )
-            // InternalRoom.g:24581:1: ( ruleSubProtocol )
+            // InternalRoom.g:24839:1: ( ( ruleSubProtocol ) )
+            // InternalRoom.g:24840:1: ( ruleSubProtocol )
             {
-            // InternalRoom.g:24581:1: ( ruleSubProtocol )
-            // InternalRoom.g:24582:1: ruleSubProtocol
+            // InternalRoom.g:24840:1: ( ruleSubProtocol )
+            // InternalRoom.g:24841:1: ruleSubProtocol
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsSubProtocolParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -66600,17 +67337,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__NameAssignment_1"
-    // InternalRoom.g:24591:1: rule__SubProtocol__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24850:1: rule__SubProtocol__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SubProtocol__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24595:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24596:1: ( RULE_ID )
+            // InternalRoom.g:24854:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24855:1: ( RULE_ID )
             {
-            // InternalRoom.g:24596:1: ( RULE_ID )
-            // InternalRoom.g:24597:1: RULE_ID
+            // InternalRoom.g:24855:1: ( RULE_ID )
+            // InternalRoom.g:24856:1: RULE_ID
             {
              before(grammarAccess.getSubProtocolAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66637,21 +67374,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__ProtocolAssignment_3"
-    // InternalRoom.g:24606:1: rule__SubProtocol__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:24865:1: rule__SubProtocol__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
     public final void rule__SubProtocol__ProtocolAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24610:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:24611:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24869:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24870:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24611:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24612:1: ( ruleFQN )
+            // InternalRoom.g:24870:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24871:1: ( ruleFQN )
             {
              before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:24613:1: ( ruleFQN )
-            // InternalRoom.g:24614:1: ruleFQN
+            // InternalRoom.g:24872:1: ( ruleFQN )
+            // InternalRoom.g:24873:1: ruleFQN
             {
              before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -66686,21 +67423,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__PrivAssignment_0"
-    // InternalRoom.g:24625:1: rule__Message__PrivAssignment_0 : ( ( 'private' ) ) ;
+    // InternalRoom.g:24884:1: rule__Message__PrivAssignment_0 : ( ( 'private' ) ) ;
     public final void rule__Message__PrivAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24629:1: ( ( ( 'private' ) ) )
-            // InternalRoom.g:24630:1: ( ( 'private' ) )
+            // InternalRoom.g:24888:1: ( ( ( 'private' ) ) )
+            // InternalRoom.g:24889:1: ( ( 'private' ) )
             {
-            // InternalRoom.g:24630:1: ( ( 'private' ) )
-            // InternalRoom.g:24631:1: ( 'private' )
+            // InternalRoom.g:24889:1: ( ( 'private' ) )
+            // InternalRoom.g:24890:1: ( 'private' )
             {
              before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); 
-            // InternalRoom.g:24632:1: ( 'private' )
-            // InternalRoom.g:24633:1: 'private'
+            // InternalRoom.g:24891:1: ( 'private' )
+            // InternalRoom.g:24892:1: 'private'
             {
              before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); 
             match(input,129,FOLLOW_2); 
@@ -66731,17 +67468,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__NameAssignment_2"
-    // InternalRoom.g:24648:1: rule__Message__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24907:1: rule__Message__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__Message__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24652:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24653:1: ( RULE_ID )
+            // InternalRoom.g:24911:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24912:1: ( RULE_ID )
             {
-            // InternalRoom.g:24653:1: ( RULE_ID )
-            // InternalRoom.g:24654:1: RULE_ID
+            // InternalRoom.g:24912:1: ( RULE_ID )
+            // InternalRoom.g:24913:1: RULE_ID
             {
              before(grammarAccess.getMessageAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66767,26 +67504,26 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "rule__Message__NameAssignment_2"
 
 
-    // $ANTLR start "rule__Message__DataAssignment_4"
-    // InternalRoom.g:24663:1: rule__Message__DataAssignment_4 : ( ruleVarDecl ) ;
-    public final void rule__Message__DataAssignment_4() throws RecognitionException {
+    // $ANTLR start "rule__Message__DataAssignment_3_1"
+    // InternalRoom.g:24922:1: rule__Message__DataAssignment_3_1 : ( ruleMessageData ) ;
+    public final void rule__Message__DataAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24667:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24668:1: ( ruleVarDecl )
+            // InternalRoom.g:24926:1: ( ( ruleMessageData ) )
+            // InternalRoom.g:24927:1: ( ruleMessageData )
             {
-            // InternalRoom.g:24668:1: ( ruleVarDecl )
-            // InternalRoom.g:24669:1: ruleVarDecl
+            // InternalRoom.g:24927:1: ( ruleMessageData )
+            // InternalRoom.g:24928:1: ruleMessageData
             {
-             before(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); 
+             before(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
-            ruleVarDecl();
+            ruleMessageData();
 
             state._fsp--;
 
-             after(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); 
+             after(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); 
 
             }
 
@@ -66805,29 +67542,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__DataAssignment_4"
+    // $ANTLR end "rule__Message__DataAssignment_3_1"
 
 
-    // $ANTLR start "rule__Message__AnnotationsAssignment_6"
-    // InternalRoom.g:24678:1: rule__Message__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
-    public final void rule__Message__AnnotationsAssignment_6() throws RecognitionException {
+    // $ANTLR start "rule__Message__AnnotationsAssignment_4"
+    // InternalRoom.g:24937:1: rule__Message__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    public final void rule__Message__AnnotationsAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24682:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:24683:1: ( ruleAnnotation )
+            // InternalRoom.g:24941:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24942:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24683:1: ( ruleAnnotation )
-            // InternalRoom.g:24684:1: ruleAnnotation
+            // InternalRoom.g:24942:1: ( ruleAnnotation )
+            // InternalRoom.g:24943:1: ruleAnnotation
             {
-             before(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
+             before(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
             ruleAnnotation();
 
             state._fsp--;
 
-             after(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
+             after(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
 
             }
 
@@ -66846,29 +67583,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__AnnotationsAssignment_6"
+    // $ANTLR end "rule__Message__AnnotationsAssignment_4"
 
 
-    // $ANTLR start "rule__Message__DocuAssignment_7"
-    // InternalRoom.g:24693:1: rule__Message__DocuAssignment_7 : ( ruleDocumentation ) ;
-    public final void rule__Message__DocuAssignment_7() throws RecognitionException {
+    // $ANTLR start "rule__Message__DocuAssignment_5"
+    // InternalRoom.g:24952:1: rule__Message__DocuAssignment_5 : ( ruleDocumentation ) ;
+    public final void rule__Message__DocuAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24697:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24698:1: ( ruleDocumentation )
+            // InternalRoom.g:24956:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24957:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24698:1: ( ruleDocumentation )
-            // InternalRoom.g:24699:1: ruleDocumentation
+            // InternalRoom.g:24957:1: ( ruleDocumentation )
+            // InternalRoom.g:24958:1: ruleDocumentation
             {
-             before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); 
+             before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
             ruleDocumentation();
 
             state._fsp--;
 
-             after(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); 
+             after(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); 
 
             }
 
@@ -66887,21 +67624,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
         }
         return ;
     }
-    // $ANTLR end "rule__Message__DocuAssignment_7"
+    // $ANTLR end "rule__Message__DocuAssignment_5"
 
 
     // $ANTLR start "rule__PortClass__UserCodeAssignment_2_1"
-    // InternalRoom.g:24708:1: rule__PortClass__UserCodeAssignment_2_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24967:1: rule__PortClass__UserCodeAssignment_2_1 : ( ruleDetailCode ) ;
     public final void rule__PortClass__UserCodeAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24712:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24713:1: ( ruleDetailCode )
+            // InternalRoom.g:24971:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24972:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24713:1: ( ruleDetailCode )
-            // InternalRoom.g:24714:1: ruleDetailCode
+            // InternalRoom.g:24972:1: ( ruleDetailCode )
+            // InternalRoom.g:24973:1: ruleDetailCode
             {
              before(grammarAccess.getPortClassAccess().getUserCodeDetailCodeParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66932,17 +67669,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__MsgHandlersAssignment_3_0"
-    // InternalRoom.g:24723:1: rule__PortClass__MsgHandlersAssignment_3_0 : ( ruleMessageHandler ) ;
+    // InternalRoom.g:24982:1: rule__PortClass__MsgHandlersAssignment_3_0 : ( ruleMessageHandler ) ;
     public final void rule__PortClass__MsgHandlersAssignment_3_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24727:1: ( ( ruleMessageHandler ) )
-            // InternalRoom.g:24728:1: ( ruleMessageHandler )
+            // InternalRoom.g:24986:1: ( ( ruleMessageHandler ) )
+            // InternalRoom.g:24987:1: ( ruleMessageHandler )
             {
-            // InternalRoom.g:24728:1: ( ruleMessageHandler )
-            // InternalRoom.g:24729:1: ruleMessageHandler
+            // InternalRoom.g:24987:1: ( ruleMessageHandler )
+            // InternalRoom.g:24988:1: ruleMessageHandler
             {
              before(grammarAccess.getPortClassAccess().getMsgHandlersMessageHandlerParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -66973,17 +67710,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__OperationsAssignment_3_1"
-    // InternalRoom.g:24738:1: rule__PortClass__OperationsAssignment_3_1 : ( rulePortOperation ) ;
+    // InternalRoom.g:24997:1: rule__PortClass__OperationsAssignment_3_1 : ( rulePortOperation ) ;
     public final void rule__PortClass__OperationsAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24742:1: ( ( rulePortOperation ) )
-            // InternalRoom.g:24743:1: ( rulePortOperation )
+            // InternalRoom.g:25001:1: ( ( rulePortOperation ) )
+            // InternalRoom.g:25002:1: ( rulePortOperation )
             {
-            // InternalRoom.g:24743:1: ( rulePortOperation )
-            // InternalRoom.g:24744:1: rulePortOperation
+            // InternalRoom.g:25002:1: ( rulePortOperation )
+            // InternalRoom.g:25003:1: rulePortOperation
             {
              before(grammarAccess.getPortClassAccess().getOperationsPortOperationParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67014,17 +67751,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__AttributesAssignment_3_2"
-    // InternalRoom.g:24753:1: rule__PortClass__AttributesAssignment_3_2 : ( ruleAttribute ) ;
+    // InternalRoom.g:25012:1: rule__PortClass__AttributesAssignment_3_2 : ( ruleAttribute ) ;
     public final void rule__PortClass__AttributesAssignment_3_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24757:1: ( ( ruleAttribute ) )
-            // InternalRoom.g:24758:1: ( ruleAttribute )
+            // InternalRoom.g:25016:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:25017:1: ( ruleAttribute )
             {
-            // InternalRoom.g:24758:1: ( ruleAttribute )
-            // InternalRoom.g:24759:1: ruleAttribute
+            // InternalRoom.g:25017:1: ( ruleAttribute )
+            // InternalRoom.g:25018:1: ruleAttribute
             {
              before(grammarAccess.getPortClassAccess().getAttributesAttributeParserRuleCall_3_2_0()); 
             pushFollow(FOLLOW_2);
@@ -67055,21 +67792,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__MsgAssignment_2"
-    // InternalRoom.g:24768:1: rule__InMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25027:1: rule__InMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__InMessageHandler__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24772:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:24773:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25031:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25032:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24773:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24774:1: ( RULE_ID )
+            // InternalRoom.g:25032:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25033:1: ( RULE_ID )
             {
              before(grammarAccess.getInMessageHandlerAccess().getMsgMessageCrossReference_2_0()); 
-            // InternalRoom.g:24775:1: ( RULE_ID )
-            // InternalRoom.g:24776:1: RULE_ID
+            // InternalRoom.g:25034:1: ( RULE_ID )
+            // InternalRoom.g:25035:1: RULE_ID
             {
              before(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67100,17 +67837,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__DetailCodeAssignment_3"
-    // InternalRoom.g:24787:1: rule__InMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25046:1: rule__InMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
     public final void rule__InMessageHandler__DetailCodeAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24791:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24792:1: ( ruleDetailCode )
+            // InternalRoom.g:25050:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25051:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24792:1: ( ruleDetailCode )
-            // InternalRoom.g:24793:1: ruleDetailCode
+            // InternalRoom.g:25051:1: ( ruleDetailCode )
+            // InternalRoom.g:25052:1: ruleDetailCode
             {
              before(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67141,21 +67878,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__MsgAssignment_2"
-    // InternalRoom.g:24802:1: rule__OutMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25061:1: rule__OutMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__OutMessageHandler__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24806:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:24807:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25065:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25066:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24807:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24808:1: ( RULE_ID )
+            // InternalRoom.g:25066:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25067:1: ( RULE_ID )
             {
              before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageCrossReference_2_0()); 
-            // InternalRoom.g:24809:1: ( RULE_ID )
-            // InternalRoom.g:24810:1: RULE_ID
+            // InternalRoom.g:25068:1: ( RULE_ID )
+            // InternalRoom.g:25069:1: RULE_ID
             {
              before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67186,17 +67923,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__DetailCodeAssignment_3"
-    // InternalRoom.g:24821:1: rule__OutMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25080:1: rule__OutMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
     public final void rule__OutMessageHandler__DetailCodeAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24825:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24826:1: ( ruleDetailCode )
+            // InternalRoom.g:25084:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25085:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24826:1: ( ruleDetailCode )
-            // InternalRoom.g:24827:1: ruleDetailCode
+            // InternalRoom.g:25085:1: ( ruleDetailCode )
+            // InternalRoom.g:25086:1: ruleDetailCode
             {
              before(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67227,21 +67964,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__AbstractAssignment_0_0"
-    // InternalRoom.g:24836:1: rule__ActorClass__AbstractAssignment_0_0 : ( ( 'abstract' ) ) ;
+    // InternalRoom.g:25095:1: rule__ActorClass__AbstractAssignment_0_0 : ( ( 'abstract' ) ) ;
     public final void rule__ActorClass__AbstractAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24840:1: ( ( ( 'abstract' ) ) )
-            // InternalRoom.g:24841:1: ( ( 'abstract' ) )
+            // InternalRoom.g:25099:1: ( ( ( 'abstract' ) ) )
+            // InternalRoom.g:25100:1: ( ( 'abstract' ) )
             {
-            // InternalRoom.g:24841:1: ( ( 'abstract' ) )
-            // InternalRoom.g:24842:1: ( 'abstract' )
+            // InternalRoom.g:25100:1: ( ( 'abstract' ) )
+            // InternalRoom.g:25101:1: ( 'abstract' )
             {
              before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); 
-            // InternalRoom.g:24843:1: ( 'abstract' )
-            // InternalRoom.g:24844:1: 'abstract'
+            // InternalRoom.g:25102:1: ( 'abstract' )
+            // InternalRoom.g:25103:1: 'abstract'
             {
              before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); 
             match(input,130,FOLLOW_2); 
@@ -67272,17 +68009,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__CommTypeAssignment_0_1"
-    // InternalRoom.g:24859:1: rule__ActorClass__CommTypeAssignment_0_1 : ( ruleComponentCommunicationType ) ;
+    // InternalRoom.g:25118:1: rule__ActorClass__CommTypeAssignment_0_1 : ( ruleComponentCommunicationType ) ;
     public final void rule__ActorClass__CommTypeAssignment_0_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24863:1: ( ( ruleComponentCommunicationType ) )
-            // InternalRoom.g:24864:1: ( ruleComponentCommunicationType )
+            // InternalRoom.g:25122:1: ( ( ruleComponentCommunicationType ) )
+            // InternalRoom.g:25123:1: ( ruleComponentCommunicationType )
             {
-            // InternalRoom.g:24864:1: ( ruleComponentCommunicationType )
-            // InternalRoom.g:24865:1: ruleComponentCommunicationType
+            // InternalRoom.g:25123:1: ( ruleComponentCommunicationType )
+            // InternalRoom.g:25124:1: ruleComponentCommunicationType
             {
              before(grammarAccess.getActorClassAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67313,17 +68050,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__NameAssignment_2"
-    // InternalRoom.g:24874:1: rule__ActorClass__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:25133:1: rule__ActorClass__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__ActorClass__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24878:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24879:1: ( RULE_ID )
+            // InternalRoom.g:25137:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25138:1: ( RULE_ID )
             {
-            // InternalRoom.g:24879:1: ( RULE_ID )
-            // InternalRoom.g:24880:1: RULE_ID
+            // InternalRoom.g:25138:1: ( RULE_ID )
+            // InternalRoom.g:25139:1: RULE_ID
             {
              before(grammarAccess.getActorClassAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67350,17 +68087,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__DocuAssignment_3"
-    // InternalRoom.g:24889:1: rule__ActorClass__DocuAssignment_3 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25148:1: rule__ActorClass__DocuAssignment_3 : ( ruleDocumentation ) ;
     public final void rule__ActorClass__DocuAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24893:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24894:1: ( ruleDocumentation )
+            // InternalRoom.g:25152:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25153:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24894:1: ( ruleDocumentation )
-            // InternalRoom.g:24895:1: ruleDocumentation
+            // InternalRoom.g:25153:1: ( ruleDocumentation )
+            // InternalRoom.g:25154:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67391,21 +68128,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__BaseAssignment_4_1"
-    // InternalRoom.g:24904:1: rule__ActorClass__BaseAssignment_4_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25163:1: rule__ActorClass__BaseAssignment_4_1 : ( ( ruleFQN ) ) ;
     public final void rule__ActorClass__BaseAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24908:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:24909:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25167:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25168:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24909:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24910:1: ( ruleFQN )
+            // InternalRoom.g:25168:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25169:1: ( ruleFQN )
             {
              before(grammarAccess.getActorClassAccess().getBaseActorClassCrossReference_4_1_0()); 
-            // InternalRoom.g:24911:1: ( ruleFQN )
-            // InternalRoom.g:24912:1: ruleFQN
+            // InternalRoom.g:25170:1: ( ruleFQN )
+            // InternalRoom.g:25171:1: ruleFQN
             {
              before(grammarAccess.getActorClassAccess().getBaseActorClassFQNParserRuleCall_4_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -67440,17 +68177,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__AnnotationsAssignment_6"
-    // InternalRoom.g:24923:1: rule__ActorClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25182:1: rule__ActorClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
     public final void rule__ActorClass__AnnotationsAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24927:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:24928:1: ( ruleAnnotation )
+            // InternalRoom.g:25186:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25187:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24928:1: ( ruleAnnotation )
-            // InternalRoom.g:24929:1: ruleAnnotation
+            // InternalRoom.g:25187:1: ( ruleAnnotation )
+            // InternalRoom.g:25188:1: ruleAnnotation
             {
              before(grammarAccess.getActorClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -67481,17 +68218,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0"
-    // InternalRoom.g:24938:1: rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 : ( ruleSPP ) ;
+    // InternalRoom.g:25197:1: rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 : ( ruleSPP ) ;
     public final void rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24942:1: ( ( ruleSPP ) )
-            // InternalRoom.g:24943:1: ( ruleSPP )
+            // InternalRoom.g:25201:1: ( ( ruleSPP ) )
+            // InternalRoom.g:25202:1: ( ruleSPP )
             {
-            // InternalRoom.g:24943:1: ( ruleSPP )
-            // InternalRoom.g:24944:1: ruleSPP
+            // InternalRoom.g:25202:1: ( ruleSPP )
+            // InternalRoom.g:25203:1: ruleSPP
             {
              before(grammarAccess.getActorClassAccess().getServiceProvisionPointsSPPParserRuleCall_7_2_0_0()); 
             pushFollow(FOLLOW_2);
@@ -67522,17 +68259,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__InterfacePortsAssignment_7_2_1"
-    // InternalRoom.g:24953:1: rule__ActorClass__InterfacePortsAssignment_7_2_1 : ( rulePort ) ;
+    // InternalRoom.g:25212:1: rule__ActorClass__InterfacePortsAssignment_7_2_1 : ( rulePort ) ;
     public final void rule__ActorClass__InterfacePortsAssignment_7_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24957:1: ( ( rulePort ) )
-            // InternalRoom.g:24958:1: ( rulePort )
+            // InternalRoom.g:25216:1: ( ( rulePort ) )
+            // InternalRoom.g:25217:1: ( rulePort )
             {
-            // InternalRoom.g:24958:1: ( rulePort )
-            // InternalRoom.g:24959:1: rulePort
+            // InternalRoom.g:25217:1: ( rulePort )
+            // InternalRoom.g:25218:1: rulePort
             {
              before(grammarAccess.getActorClassAccess().getInterfacePortsPortParserRuleCall_7_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67563,17 +68300,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__StructureDocuAssignment_8_1"
-    // InternalRoom.g:24968:1: rule__ActorClass__StructureDocuAssignment_8_1 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25227:1: rule__ActorClass__StructureDocuAssignment_8_1 : ( ruleDocumentation ) ;
     public final void rule__ActorClass__StructureDocuAssignment_8_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24972:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24973:1: ( ruleDocumentation )
+            // InternalRoom.g:25231:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25232:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24973:1: ( ruleDocumentation )
-            // InternalRoom.g:24974:1: ruleDocumentation
+            // InternalRoom.g:25232:1: ( ruleDocumentation )
+            // InternalRoom.g:25233:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getStructureDocuDocumentationParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67604,17 +68341,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UserCode1Assignment_8_3_1"
-    // InternalRoom.g:24983:1: rule__ActorClass__UserCode1Assignment_8_3_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25242:1: rule__ActorClass__UserCode1Assignment_8_3_1 : ( ruleDetailCode ) ;
     public final void rule__ActorClass__UserCode1Assignment_8_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24987:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:24988:1: ( ruleDetailCode )
+            // InternalRoom.g:25246:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25247:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24988:1: ( ruleDetailCode )
-            // InternalRoom.g:24989:1: ruleDetailCode
+            // InternalRoom.g:25247:1: ( ruleDetailCode )
+            // InternalRoom.g:25248:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode1DetailCodeParserRuleCall_8_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67645,17 +68382,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UserCode2Assignment_8_4_1"
-    // InternalRoom.g:24998:1: rule__ActorClass__UserCode2Assignment_8_4_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25257:1: rule__ActorClass__UserCode2Assignment_8_4_1 : ( ruleDetailCode ) ;
     public final void rule__ActorClass__UserCode2Assignment_8_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25002:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:25003:1: ( ruleDetailCode )
+            // InternalRoom.g:25261:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25262:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25003:1: ( ruleDetailCode )
-            // InternalRoom.g:25004:1: ruleDetailCode
+            // InternalRoom.g:25262:1: ( ruleDetailCode )
+            // InternalRoom.g:25263:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode2DetailCodeParserRuleCall_8_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67686,17 +68423,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__UserCode3Assignment_8_5_1"
-    // InternalRoom.g:25013:1: rule__ActorClass__UserCode3Assignment_8_5_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25272:1: rule__ActorClass__UserCode3Assignment_8_5_1 : ( ruleDetailCode ) ;
     public final void rule__ActorClass__UserCode3Assignment_8_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25017:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:25018:1: ( ruleDetailCode )
+            // InternalRoom.g:25276:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25277:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25018:1: ( ruleDetailCode )
-            // InternalRoom.g:25019:1: ruleDetailCode
+            // InternalRoom.g:25277:1: ( ruleDetailCode )
+            // InternalRoom.g:25278:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode3DetailCodeParserRuleCall_8_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67727,17 +68464,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ConnectionsAssignment_8_6_0"
-    // InternalRoom.g:25028:1: rule__ActorClass__ConnectionsAssignment_8_6_0 : ( ruleLayerConnection ) ;
+    // InternalRoom.g:25287:1: rule__ActorClass__ConnectionsAssignment_8_6_0 : ( ruleLayerConnection ) ;
     public final void rule__ActorClass__ConnectionsAssignment_8_6_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25032:1: ( ( ruleLayerConnection ) )
-            // InternalRoom.g:25033:1: ( ruleLayerConnection )
+            // InternalRoom.g:25291:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25292:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25033:1: ( ruleLayerConnection )
-            // InternalRoom.g:25034:1: ruleLayerConnection
+            // InternalRoom.g:25292:1: ( ruleLayerConnection )
+            // InternalRoom.g:25293:1: ruleLayerConnection
             {
              before(grammarAccess.getActorClassAccess().getConnectionsLayerConnectionParserRuleCall_8_6_0_0()); 
             pushFollow(FOLLOW_2);
@@ -67768,17 +68505,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__BindingsAssignment_8_6_1"
-    // InternalRoom.g:25043:1: rule__ActorClass__BindingsAssignment_8_6_1 : ( ruleBinding ) ;
+    // InternalRoom.g:25302:1: rule__ActorClass__BindingsAssignment_8_6_1 : ( ruleBinding ) ;
     public final void rule__ActorClass__BindingsAssignment_8_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25047:1: ( ( ruleBinding ) )
-            // InternalRoom.g:25048:1: ( ruleBinding )
+            // InternalRoom.g:25306:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25307:1: ( ruleBinding )
             {
-            // InternalRoom.g:25048:1: ( ruleBinding )
-            // InternalRoom.g:25049:1: ruleBinding
+            // InternalRoom.g:25307:1: ( ruleBinding )
+            // InternalRoom.g:25308:1: ruleBinding
             {
              before(grammarAccess.getActorClassAccess().getBindingsBindingParserRuleCall_8_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67809,17 +68546,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ServiceImplementationsAssignment_8_6_2"
-    // InternalRoom.g:25058:1: rule__ActorClass__ServiceImplementationsAssignment_8_6_2 : ( ruleServiceImplementation ) ;
+    // InternalRoom.g:25317:1: rule__ActorClass__ServiceImplementationsAssignment_8_6_2 : ( ruleServiceImplementation ) ;
     public final void rule__ActorClass__ServiceImplementationsAssignment_8_6_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25062:1: ( ( ruleServiceImplementation ) )
-            // InternalRoom.g:25063:1: ( ruleServiceImplementation )
+            // InternalRoom.g:25321:1: ( ( ruleServiceImplementation ) )
+            // InternalRoom.g:25322:1: ( ruleServiceImplementation )
             {
-            // InternalRoom.g:25063:1: ( ruleServiceImplementation )
-            // InternalRoom.g:25064:1: ruleServiceImplementation
+            // InternalRoom.g:25322:1: ( ruleServiceImplementation )
+            // InternalRoom.g:25323:1: ruleServiceImplementation
             {
              before(grammarAccess.getActorClassAccess().getServiceImplementationsServiceImplementationParserRuleCall_8_6_2_0()); 
             pushFollow(FOLLOW_2);
@@ -67850,17 +68587,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__AttributesAssignment_8_6_3"
-    // InternalRoom.g:25073:1: rule__ActorClass__AttributesAssignment_8_6_3 : ( ruleAttribute ) ;
+    // InternalRoom.g:25332:1: rule__ActorClass__AttributesAssignment_8_6_3 : ( ruleAttribute ) ;
     public final void rule__ActorClass__AttributesAssignment_8_6_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25077:1: ( ( ruleAttribute ) )
-            // InternalRoom.g:25078:1: ( ruleAttribute )
+            // InternalRoom.g:25336:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:25337:1: ( ruleAttribute )
             {
-            // InternalRoom.g:25078:1: ( ruleAttribute )
-            // InternalRoom.g:25079:1: ruleAttribute
+            // InternalRoom.g:25337:1: ( ruleAttribute )
+            // InternalRoom.g:25338:1: ruleAttribute
             {
              before(grammarAccess.getActorClassAccess().getAttributesAttributeParserRuleCall_8_6_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67891,17 +68628,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ActorRefsAssignment_8_6_4"
-    // InternalRoom.g:25088:1: rule__ActorClass__ActorRefsAssignment_8_6_4 : ( ruleActorRef ) ;
+    // InternalRoom.g:25347:1: rule__ActorClass__ActorRefsAssignment_8_6_4 : ( ruleActorRef ) ;
     public final void rule__ActorClass__ActorRefsAssignment_8_6_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25092:1: ( ( ruleActorRef ) )
-            // InternalRoom.g:25093:1: ( ruleActorRef )
+            // InternalRoom.g:25351:1: ( ( ruleActorRef ) )
+            // InternalRoom.g:25352:1: ( ruleActorRef )
             {
-            // InternalRoom.g:25093:1: ( ruleActorRef )
-            // InternalRoom.g:25094:1: ruleActorRef
+            // InternalRoom.g:25352:1: ( ruleActorRef )
+            // InternalRoom.g:25353:1: ruleActorRef
             {
              before(grammarAccess.getActorClassAccess().getActorRefsActorRefParserRuleCall_8_6_4_0()); 
             pushFollow(FOLLOW_2);
@@ -67932,17 +68669,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ServiceAccessPointsAssignment_8_6_5"
-    // InternalRoom.g:25103:1: rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 : ( ruleSAP ) ;
+    // InternalRoom.g:25362:1: rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 : ( ruleSAP ) ;
     public final void rule__ActorClass__ServiceAccessPointsAssignment_8_6_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25107:1: ( ( ruleSAP ) )
-            // InternalRoom.g:25108:1: ( ruleSAP )
+            // InternalRoom.g:25366:1: ( ( ruleSAP ) )
+            // InternalRoom.g:25367:1: ( ruleSAP )
             {
-            // InternalRoom.g:25108:1: ( ruleSAP )
-            // InternalRoom.g:25109:1: ruleSAP
+            // InternalRoom.g:25367:1: ( ruleSAP )
+            // InternalRoom.g:25368:1: ruleSAP
             {
              before(grammarAccess.getActorClassAccess().getServiceAccessPointsSAPParserRuleCall_8_6_5_0()); 
             pushFollow(FOLLOW_2);
@@ -67973,17 +68710,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__InternalPortsAssignment_8_6_6"
-    // InternalRoom.g:25118:1: rule__ActorClass__InternalPortsAssignment_8_6_6 : ( rulePort ) ;
+    // InternalRoom.g:25377:1: rule__ActorClass__InternalPortsAssignment_8_6_6 : ( rulePort ) ;
     public final void rule__ActorClass__InternalPortsAssignment_8_6_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25122:1: ( ( rulePort ) )
-            // InternalRoom.g:25123:1: ( rulePort )
+            // InternalRoom.g:25381:1: ( ( rulePort ) )
+            // InternalRoom.g:25382:1: ( rulePort )
             {
-            // InternalRoom.g:25123:1: ( rulePort )
-            // InternalRoom.g:25124:1: rulePort
+            // InternalRoom.g:25382:1: ( rulePort )
+            // InternalRoom.g:25383:1: rulePort
             {
              before(grammarAccess.getActorClassAccess().getInternalPortsPortParserRuleCall_8_6_6_0()); 
             pushFollow(FOLLOW_2);
@@ -68014,17 +68751,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__ExternalPortsAssignment_8_6_7"
-    // InternalRoom.g:25133:1: rule__ActorClass__ExternalPortsAssignment_8_6_7 : ( ruleExternalPort ) ;
+    // InternalRoom.g:25392:1: rule__ActorClass__ExternalPortsAssignment_8_6_7 : ( ruleExternalPort ) ;
     public final void rule__ActorClass__ExternalPortsAssignment_8_6_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25137:1: ( ( ruleExternalPort ) )
-            // InternalRoom.g:25138:1: ( ruleExternalPort )
+            // InternalRoom.g:25396:1: ( ( ruleExternalPort ) )
+            // InternalRoom.g:25397:1: ( ruleExternalPort )
             {
-            // InternalRoom.g:25138:1: ( ruleExternalPort )
-            // InternalRoom.g:25139:1: ruleExternalPort
+            // InternalRoom.g:25397:1: ( ruleExternalPort )
+            // InternalRoom.g:25398:1: ruleExternalPort
             {
              before(grammarAccess.getActorClassAccess().getExternalPortsExternalPortParserRuleCall_8_6_7_0()); 
             pushFollow(FOLLOW_2);
@@ -68055,17 +68792,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__BehaviorDocuAssignment_9_1"
-    // InternalRoom.g:25148:1: rule__ActorClass__BehaviorDocuAssignment_9_1 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25407:1: rule__ActorClass__BehaviorDocuAssignment_9_1 : ( ruleDocumentation ) ;
     public final void rule__ActorClass__BehaviorDocuAssignment_9_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25152:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:25153:1: ( ruleDocumentation )
+            // InternalRoom.g:25411:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25412:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25153:1: ( ruleDocumentation )
-            // InternalRoom.g:25154:1: ruleDocumentation
+            // InternalRoom.g:25412:1: ( ruleDocumentation )
+            // InternalRoom.g:25413:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getBehaviorDocuDocumentationParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68096,17 +68833,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__BehaviorAnnotationsAssignment_9_3"
-    // InternalRoom.g:25163:1: rule__ActorClass__BehaviorAnnotationsAssignment_9_3 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25422:1: rule__ActorClass__BehaviorAnnotationsAssignment_9_3 : ( ruleAnnotation ) ;
     public final void rule__ActorClass__BehaviorAnnotationsAssignment_9_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25167:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:25168:1: ( ruleAnnotation )
+            // InternalRoom.g:25426:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25427:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25168:1: ( ruleAnnotation )
-            // InternalRoom.g:25169:1: ruleAnnotation
+            // InternalRoom.g:25427:1: ( ruleAnnotation )
+            // InternalRoom.g:25428:1: ruleAnnotation
             {
              before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAnnotationParserRuleCall_9_3_0()); 
             pushFollow(FOLLOW_2);
@@ -68137,17 +68874,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__OperationsAssignment_9_4_0"
-    // InternalRoom.g:25178:1: rule__ActorClass__OperationsAssignment_9_4_0 : ( ruleStandardOperation ) ;
+    // InternalRoom.g:25437:1: rule__ActorClass__OperationsAssignment_9_4_0 : ( ruleStandardOperation ) ;
     public final void rule__ActorClass__OperationsAssignment_9_4_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25182:1: ( ( ruleStandardOperation ) )
-            // InternalRoom.g:25183:1: ( ruleStandardOperation )
+            // InternalRoom.g:25441:1: ( ( ruleStandardOperation ) )
+            // InternalRoom.g:25442:1: ( ruleStandardOperation )
             {
-            // InternalRoom.g:25183:1: ( ruleStandardOperation )
-            // InternalRoom.g:25184:1: ruleStandardOperation
+            // InternalRoom.g:25442:1: ( ruleStandardOperation )
+            // InternalRoom.g:25443:1: ruleStandardOperation
             {
              before(grammarAccess.getActorClassAccess().getOperationsStandardOperationParserRuleCall_9_4_0_0()); 
             pushFollow(FOLLOW_2);
@@ -68178,17 +68915,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__StructorsAssignment_9_4_1"
-    // InternalRoom.g:25193:1: rule__ActorClass__StructorsAssignment_9_4_1 : ( ruleClassStructor ) ;
+    // InternalRoom.g:25452:1: rule__ActorClass__StructorsAssignment_9_4_1 : ( ruleClassStructor ) ;
     public final void rule__ActorClass__StructorsAssignment_9_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25197:1: ( ( ruleClassStructor ) )
-            // InternalRoom.g:25198:1: ( ruleClassStructor )
+            // InternalRoom.g:25456:1: ( ( ruleClassStructor ) )
+            // InternalRoom.g:25457:1: ( ruleClassStructor )
             {
-            // InternalRoom.g:25198:1: ( ruleClassStructor )
-            // InternalRoom.g:25199:1: ruleClassStructor
+            // InternalRoom.g:25457:1: ( ruleClassStructor )
+            // InternalRoom.g:25458:1: ruleClassStructor
             {
              before(grammarAccess.getActorClassAccess().getStructorsClassStructorParserRuleCall_9_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68219,17 +68956,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__StateMachineAssignment_9_5"
-    // InternalRoom.g:25208:1: rule__ActorClass__StateMachineAssignment_9_5 : ( ruleStateMachine ) ;
+    // InternalRoom.g:25467:1: rule__ActorClass__StateMachineAssignment_9_5 : ( ruleStateMachine ) ;
     public final void rule__ActorClass__StateMachineAssignment_9_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25212:1: ( ( ruleStateMachine ) )
-            // InternalRoom.g:25213:1: ( ruleStateMachine )
+            // InternalRoom.g:25471:1: ( ( ruleStateMachine ) )
+            // InternalRoom.g:25472:1: ( ruleStateMachine )
             {
-            // InternalRoom.g:25213:1: ( ruleStateMachine )
-            // InternalRoom.g:25214:1: ruleStateMachine
+            // InternalRoom.g:25472:1: ( ruleStateMachine )
+            // InternalRoom.g:25473:1: ruleStateMachine
             {
              before(grammarAccess.getActorClassAccess().getStateMachineStateMachineParserRuleCall_9_5_0()); 
             pushFollow(FOLLOW_2);
@@ -68260,21 +68997,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__ConjugatedAssignment_0"
-    // InternalRoom.g:25223:1: rule__Port__ConjugatedAssignment_0 : ( ( 'conjugated' ) ) ;
+    // InternalRoom.g:25482:1: rule__Port__ConjugatedAssignment_0 : ( ( 'conjugated' ) ) ;
     public final void rule__Port__ConjugatedAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25227:1: ( ( ( 'conjugated' ) ) )
-            // InternalRoom.g:25228:1: ( ( 'conjugated' ) )
+            // InternalRoom.g:25486:1: ( ( ( 'conjugated' ) ) )
+            // InternalRoom.g:25487:1: ( ( 'conjugated' ) )
             {
-            // InternalRoom.g:25228:1: ( ( 'conjugated' ) )
-            // InternalRoom.g:25229:1: ( 'conjugated' )
+            // InternalRoom.g:25487:1: ( ( 'conjugated' ) )
+            // InternalRoom.g:25488:1: ( 'conjugated' )
             {
              before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); 
-            // InternalRoom.g:25230:1: ( 'conjugated' )
-            // InternalRoom.g:25231:1: 'conjugated'
+            // InternalRoom.g:25489:1: ( 'conjugated' )
+            // InternalRoom.g:25490:1: 'conjugated'
             {
              before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); 
             match(input,70,FOLLOW_2); 
@@ -68305,17 +69042,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__NameAssignment_2"
-    // InternalRoom.g:25246:1: rule__Port__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:25505:1: rule__Port__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__Port__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25250:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25251:1: ( RULE_ID )
+            // InternalRoom.g:25509:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25510:1: ( RULE_ID )
             {
-            // InternalRoom.g:25251:1: ( RULE_ID )
-            // InternalRoom.g:25252:1: RULE_ID
+            // InternalRoom.g:25510:1: ( RULE_ID )
+            // InternalRoom.g:25511:1: RULE_ID
             {
              before(grammarAccess.getPortAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68342,17 +69079,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__MultiplicityAssignment_3"
-    // InternalRoom.g:25261:1: rule__Port__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
+    // InternalRoom.g:25520:1: rule__Port__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
     public final void rule__Port__MultiplicityAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25265:1: ( ( ruleMULTIPLICITY ) )
-            // InternalRoom.g:25266:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:25524:1: ( ( ruleMULTIPLICITY ) )
+            // InternalRoom.g:25525:1: ( ruleMULTIPLICITY )
             {
-            // InternalRoom.g:25266:1: ( ruleMULTIPLICITY )
-            // InternalRoom.g:25267:1: ruleMULTIPLICITY
+            // InternalRoom.g:25525:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:25526:1: ruleMULTIPLICITY
             {
              before(grammarAccess.getPortAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -68383,21 +69120,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__ProtocolAssignment_5"
-    // InternalRoom.g:25276:1: rule__Port__ProtocolAssignment_5 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25535:1: rule__Port__ProtocolAssignment_5 : ( ( ruleFQN ) ) ;
     public final void rule__Port__ProtocolAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25280:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:25281:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25539:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25540:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25281:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25282:1: ( ruleFQN )
+            // InternalRoom.g:25540:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25541:1: ( ruleFQN )
             {
              before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassCrossReference_5_0()); 
-            // InternalRoom.g:25283:1: ( ruleFQN )
-            // InternalRoom.g:25284:1: ruleFQN
+            // InternalRoom.g:25542:1: ( ruleFQN )
+            // InternalRoom.g:25543:1: ruleFQN
             {
              before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68432,17 +69169,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__AnnotationsAssignment_6"
-    // InternalRoom.g:25295:1: rule__Port__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25554:1: rule__Port__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
     public final void rule__Port__AnnotationsAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25299:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:25300:1: ( ruleAnnotation )
+            // InternalRoom.g:25558:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25559:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25300:1: ( ruleAnnotation )
-            // InternalRoom.g:25301:1: ruleAnnotation
+            // InternalRoom.g:25559:1: ( ruleAnnotation )
+            // InternalRoom.g:25560:1: ruleAnnotation
             {
              before(grammarAccess.getPortAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -68473,17 +69210,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__DocuAssignment_7"
-    // InternalRoom.g:25310:1: rule__Port__DocuAssignment_7 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25569:1: rule__Port__DocuAssignment_7 : ( ruleDocumentation ) ;
     public final void rule__Port__DocuAssignment_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25314:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:25315:1: ( ruleDocumentation )
+            // InternalRoom.g:25573:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25574:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25315:1: ( ruleDocumentation )
-            // InternalRoom.g:25316:1: ruleDocumentation
+            // InternalRoom.g:25574:1: ( ruleDocumentation )
+            // InternalRoom.g:25575:1: ruleDocumentation
             {
              before(grammarAccess.getPortAccess().getDocuDocumentationParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -68514,21 +69251,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__InterfacePortAssignment_2"
-    // InternalRoom.g:25325:1: rule__ExternalPort__InterfacePortAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25584:1: rule__ExternalPort__InterfacePortAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__ExternalPort__InterfacePortAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25329:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25330:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25588:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25589:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25330:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25331:1: ( RULE_ID )
+            // InternalRoom.g:25589:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25590:1: ( RULE_ID )
             {
              before(grammarAccess.getExternalPortAccess().getInterfacePortPortCrossReference_2_0()); 
-            // InternalRoom.g:25332:1: ( RULE_ID )
-            // InternalRoom.g:25333:1: RULE_ID
+            // InternalRoom.g:25591:1: ( RULE_ID )
+            // InternalRoom.g:25592:1: RULE_ID
             {
              before(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68559,17 +69296,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__NameAssignment_1"
-    // InternalRoom.g:25344:1: rule__SAP__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25603:1: rule__SAP__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SAP__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25348:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25349:1: ( RULE_ID )
+            // InternalRoom.g:25607:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25608:1: ( RULE_ID )
             {
-            // InternalRoom.g:25349:1: ( RULE_ID )
-            // InternalRoom.g:25350:1: RULE_ID
+            // InternalRoom.g:25608:1: ( RULE_ID )
+            // InternalRoom.g:25609:1: RULE_ID
             {
              before(grammarAccess.getSAPAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68596,21 +69333,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__ProtocolAssignment_3"
-    // InternalRoom.g:25359:1: rule__SAP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25618:1: rule__SAP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
     public final void rule__SAP__ProtocolAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25363:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:25364:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25622:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25623:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25364:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25365:1: ( ruleFQN )
+            // InternalRoom.g:25623:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25624:1: ( ruleFQN )
             {
              before(grammarAccess.getSAPAccess().getProtocolProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:25366:1: ( ruleFQN )
-            // InternalRoom.g:25367:1: ruleFQN
+            // InternalRoom.g:25625:1: ( ruleFQN )
+            // InternalRoom.g:25626:1: ruleFQN
             {
              before(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68645,17 +69382,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__NameAssignment_1"
-    // InternalRoom.g:25378:1: rule__SPP__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25637:1: rule__SPP__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SPP__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25382:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25383:1: ( RULE_ID )
+            // InternalRoom.g:25641:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25642:1: ( RULE_ID )
             {
-            // InternalRoom.g:25383:1: ( RULE_ID )
-            // InternalRoom.g:25384:1: RULE_ID
+            // InternalRoom.g:25642:1: ( RULE_ID )
+            // InternalRoom.g:25643:1: RULE_ID
             {
              before(grammarAccess.getSPPAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68682,21 +69419,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__ProtocolAssignment_3"
-    // InternalRoom.g:25393:1: rule__SPP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25652:1: rule__SPP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
     public final void rule__SPP__ProtocolAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25397:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:25398:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25656:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25657:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25398:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25399:1: ( ruleFQN )
+            // InternalRoom.g:25657:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25658:1: ( ruleFQN )
             {
              before(grammarAccess.getSPPAccess().getProtocolProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:25400:1: ( ruleFQN )
-            // InternalRoom.g:25401:1: ruleFQN
+            // InternalRoom.g:25659:1: ( ruleFQN )
+            // InternalRoom.g:25660:1: ruleFQN
             {
              before(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68731,21 +69468,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__SppAssignment_2"
-    // InternalRoom.g:25412:1: rule__ServiceImplementation__SppAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25671:1: rule__ServiceImplementation__SppAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__ServiceImplementation__SppAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25416:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25417:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25675:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25676:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25417:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25418:1: ( RULE_ID )
+            // InternalRoom.g:25676:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25677:1: ( RULE_ID )
             {
              before(grammarAccess.getServiceImplementationAccess().getSppSPPCrossReference_2_0()); 
-            // InternalRoom.g:25419:1: ( RULE_ID )
-            // InternalRoom.g:25420:1: RULE_ID
+            // InternalRoom.g:25678:1: ( RULE_ID )
+            // InternalRoom.g:25679:1: RULE_ID
             {
              before(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68776,17 +69513,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__NameAssignment_1"
-    // InternalRoom.g:25431:1: rule__LogicalSystem__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25690:1: rule__LogicalSystem__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__LogicalSystem__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25435:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25436:1: ( RULE_ID )
+            // InternalRoom.g:25694:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25695:1: ( RULE_ID )
             {
-            // InternalRoom.g:25436:1: ( RULE_ID )
-            // InternalRoom.g:25437:1: RULE_ID
+            // InternalRoom.g:25695:1: ( RULE_ID )
+            // InternalRoom.g:25696:1: RULE_ID
             {
              before(grammarAccess.getLogicalSystemAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68813,17 +69550,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__DocuAssignment_2"
-    // InternalRoom.g:25446:1: rule__LogicalSystem__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25705:1: rule__LogicalSystem__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__LogicalSystem__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25450:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:25451:1: ( ruleDocumentation )
+            // InternalRoom.g:25709:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25710:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25451:1: ( ruleDocumentation )
-            // InternalRoom.g:25452:1: ruleDocumentation
+            // InternalRoom.g:25710:1: ( ruleDocumentation )
+            // InternalRoom.g:25711:1: ruleDocumentation
             {
              before(grammarAccess.getLogicalSystemAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -68854,17 +69591,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__AnnotationsAssignment_4"
-    // InternalRoom.g:25461:1: rule__LogicalSystem__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25720:1: rule__LogicalSystem__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
     public final void rule__LogicalSystem__AnnotationsAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25465:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:25466:1: ( ruleAnnotation )
+            // InternalRoom.g:25724:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25725:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25466:1: ( ruleAnnotation )
-            // InternalRoom.g:25467:1: ruleAnnotation
+            // InternalRoom.g:25725:1: ( ruleAnnotation )
+            // InternalRoom.g:25726:1: ruleAnnotation
             {
              before(grammarAccess.getLogicalSystemAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -68895,17 +69632,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__ConnectionsAssignment_5_0"
-    // InternalRoom.g:25476:1: rule__LogicalSystem__ConnectionsAssignment_5_0 : ( ruleLayerConnection ) ;
+    // InternalRoom.g:25735:1: rule__LogicalSystem__ConnectionsAssignment_5_0 : ( ruleLayerConnection ) ;
     public final void rule__LogicalSystem__ConnectionsAssignment_5_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25480:1: ( ( ruleLayerConnection ) )
-            // InternalRoom.g:25481:1: ( ruleLayerConnection )
+            // InternalRoom.g:25739:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25740:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25481:1: ( ruleLayerConnection )
-            // InternalRoom.g:25482:1: ruleLayerConnection
+            // InternalRoom.g:25740:1: ( ruleLayerConnection )
+            // InternalRoom.g:25741:1: ruleLayerConnection
             {
              before(grammarAccess.getLogicalSystemAccess().getConnectionsLayerConnectionParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -68936,17 +69673,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__BindingsAssignment_5_1"
-    // InternalRoom.g:25491:1: rule__LogicalSystem__BindingsAssignment_5_1 : ( ruleBinding ) ;
+    // InternalRoom.g:25750:1: rule__LogicalSystem__BindingsAssignment_5_1 : ( ruleBinding ) ;
     public final void rule__LogicalSystem__BindingsAssignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25495:1: ( ( ruleBinding ) )
-            // InternalRoom.g:25496:1: ( ruleBinding )
+            // InternalRoom.g:25754:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25755:1: ( ruleBinding )
             {
-            // InternalRoom.g:25496:1: ( ruleBinding )
-            // InternalRoom.g:25497:1: ruleBinding
+            // InternalRoom.g:25755:1: ( ruleBinding )
+            // InternalRoom.g:25756:1: ruleBinding
             {
              before(grammarAccess.getLogicalSystemAccess().getBindingsBindingParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68977,17 +69714,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__SubSystemsAssignment_5_2"
-    // InternalRoom.g:25506:1: rule__LogicalSystem__SubSystemsAssignment_5_2 : ( ruleSubSystemRef ) ;
+    // InternalRoom.g:25765:1: rule__LogicalSystem__SubSystemsAssignment_5_2 : ( ruleSubSystemRef ) ;
     public final void rule__LogicalSystem__SubSystemsAssignment_5_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25510:1: ( ( ruleSubSystemRef ) )
-            // InternalRoom.g:25511:1: ( ruleSubSystemRef )
+            // InternalRoom.g:25769:1: ( ( ruleSubSystemRef ) )
+            // InternalRoom.g:25770:1: ( ruleSubSystemRef )
             {
-            // InternalRoom.g:25511:1: ( ruleSubSystemRef )
-            // InternalRoom.g:25512:1: ruleSubSystemRef
+            // InternalRoom.g:25770:1: ( ruleSubSystemRef )
+            // InternalRoom.g:25771:1: ruleSubSystemRef
             {
              before(grammarAccess.getLogicalSystemAccess().getSubSystemsSubSystemRefParserRuleCall_5_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69018,17 +69755,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__NameAssignment_1"
-    // InternalRoom.g:25521:1: rule__SubSystemRef__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25780:1: rule__SubSystemRef__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SubSystemRef__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25525:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25526:1: ( RULE_ID )
+            // InternalRoom.g:25784:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25785:1: ( RULE_ID )
             {
-            // InternalRoom.g:25526:1: ( RULE_ID )
-            // InternalRoom.g:25527:1: RULE_ID
+            // InternalRoom.g:25785:1: ( RULE_ID )
+            // InternalRoom.g:25786:1: RULE_ID
             {
              before(grammarAccess.getSubSystemRefAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69055,21 +69792,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__TypeAssignment_3"
-    // InternalRoom.g:25536:1: rule__SubSystemRef__TypeAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25795:1: rule__SubSystemRef__TypeAssignment_3 : ( ( ruleFQN ) ) ;
     public final void rule__SubSystemRef__TypeAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25540:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:25541:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25799:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25800:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25541:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25542:1: ( ruleFQN )
+            // InternalRoom.g:25800:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25801:1: ( ruleFQN )
             {
              before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassCrossReference_3_0()); 
-            // InternalRoom.g:25543:1: ( ruleFQN )
-            // InternalRoom.g:25544:1: ruleFQN
+            // InternalRoom.g:25802:1: ( ruleFQN )
+            // InternalRoom.g:25803:1: ruleFQN
             {
              before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -69104,17 +69841,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__DocuAssignment_4"
-    // InternalRoom.g:25555:1: rule__SubSystemRef__DocuAssignment_4 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25814:1: rule__SubSystemRef__DocuAssignment_4 : ( ruleDocumentation ) ;
     public final void rule__SubSystemRef__DocuAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25559:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:25560:1: ( ruleDocumentation )
+            // InternalRoom.g:25818:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25819:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25560:1: ( ruleDocumentation )
-            // InternalRoom.g:25561:1: ruleDocumentation
+            // InternalRoom.g:25819:1: ( ruleDocumentation )
+            // InternalRoom.g:25820:1: ruleDocumentation
             {
              before(grammarAccess.getSubSystemRefAccess().getDocuDocumentationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69145,17 +69882,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__NameAssignment_1"
-    // InternalRoom.g:25570:1: rule__SubSystemClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25829:1: rule__SubSystemClass__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SubSystemClass__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25574:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25575:1: ( RULE_ID )
+            // InternalRoom.g:25833:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25834:1: ( RULE_ID )
             {
-            // InternalRoom.g:25575:1: ( RULE_ID )
-            // InternalRoom.g:25576:1: RULE_ID
+            // InternalRoom.g:25834:1: ( RULE_ID )
+            // InternalRoom.g:25835:1: RULE_ID
             {
              before(grammarAccess.getSubSystemClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69182,17 +69919,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__DocuAssignment_2"
-    // InternalRoom.g:25585:1: rule__SubSystemClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25844:1: rule__SubSystemClass__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__SubSystemClass__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25589:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:25590:1: ( ruleDocumentation )
+            // InternalRoom.g:25848:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25849:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25590:1: ( ruleDocumentation )
-            // InternalRoom.g:25591:1: ruleDocumentation
+            // InternalRoom.g:25849:1: ( ruleDocumentation )
+            // InternalRoom.g:25850:1: ruleDocumentation
             {
              before(grammarAccess.getSubSystemClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69223,17 +69960,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__AnnotationsAssignment_4"
-    // InternalRoom.g:25600:1: rule__SubSystemClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25859:1: rule__SubSystemClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
     public final void rule__SubSystemClass__AnnotationsAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25604:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:25605:1: ( ruleAnnotation )
+            // InternalRoom.g:25863:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25864:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25605:1: ( ruleAnnotation )
-            // InternalRoom.g:25606:1: ruleAnnotation
+            // InternalRoom.g:25864:1: ( ruleAnnotation )
+            // InternalRoom.g:25865:1: ruleAnnotation
             {
              before(grammarAccess.getSubSystemClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69264,17 +70001,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__UserCode1Assignment_5_1"
-    // InternalRoom.g:25615:1: rule__SubSystemClass__UserCode1Assignment_5_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25874:1: rule__SubSystemClass__UserCode1Assignment_5_1 : ( ruleDetailCode ) ;
     public final void rule__SubSystemClass__UserCode1Assignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25619:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:25620:1: ( ruleDetailCode )
+            // InternalRoom.g:25878:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25879:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25620:1: ( ruleDetailCode )
-            // InternalRoom.g:25621:1: ruleDetailCode
+            // InternalRoom.g:25879:1: ( ruleDetailCode )
+            // InternalRoom.g:25880:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode1DetailCodeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69305,17 +70042,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__UserCode2Assignment_6_1"
-    // InternalRoom.g:25630:1: rule__SubSystemClass__UserCode2Assignment_6_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25889:1: rule__SubSystemClass__UserCode2Assignment_6_1 : ( ruleDetailCode ) ;
     public final void rule__SubSystemClass__UserCode2Assignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25634:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:25635:1: ( ruleDetailCode )
+            // InternalRoom.g:25893:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25894:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25635:1: ( ruleDetailCode )
-            // InternalRoom.g:25636:1: ruleDetailCode
+            // InternalRoom.g:25894:1: ( ruleDetailCode )
+            // InternalRoom.g:25895:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode2DetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69346,17 +70083,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__UserCode3Assignment_7_1"
-    // InternalRoom.g:25645:1: rule__SubSystemClass__UserCode3Assignment_7_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:25904:1: rule__SubSystemClass__UserCode3Assignment_7_1 : ( ruleDetailCode ) ;
     public final void rule__SubSystemClass__UserCode3Assignment_7_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25649:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:25650:1: ( ruleDetailCode )
+            // InternalRoom.g:25908:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25909:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25650:1: ( ruleDetailCode )
-            // InternalRoom.g:25651:1: ruleDetailCode
+            // InternalRoom.g:25909:1: ( ruleDetailCode )
+            // InternalRoom.g:25910:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode3DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69387,17 +70124,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0"
-    // InternalRoom.g:25660:1: rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 : ( ruleActorInstanceMapping ) ;
+    // InternalRoom.g:25919:1: rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 : ( ruleActorInstanceMapping ) ;
     public final void rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25664:1: ( ( ruleActorInstanceMapping ) )
-            // InternalRoom.g:25665:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:25923:1: ( ( ruleActorInstanceMapping ) )
+            // InternalRoom.g:25924:1: ( ruleActorInstanceMapping )
             {
-            // InternalRoom.g:25665:1: ( ruleActorInstanceMapping )
-            // InternalRoom.g:25666:1: ruleActorInstanceMapping
+            // InternalRoom.g:25924:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:25925:1: ruleActorInstanceMapping
             {
              before(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_8_0_0()); 
             pushFollow(FOLLOW_2);
@@ -69428,17 +70165,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__ThreadsAssignment_8_1"
-    // InternalRoom.g:25675:1: rule__SubSystemClass__ThreadsAssignment_8_1 : ( ruleLogicalThread ) ;
+    // InternalRoom.g:25934:1: rule__SubSystemClass__ThreadsAssignment_8_1 : ( ruleLogicalThread ) ;
     public final void rule__SubSystemClass__ThreadsAssignment_8_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25679:1: ( ( ruleLogicalThread ) )
-            // InternalRoom.g:25680:1: ( ruleLogicalThread )
+            // InternalRoom.g:25938:1: ( ( ruleLogicalThread ) )
+            // InternalRoom.g:25939:1: ( ruleLogicalThread )
             {
-            // InternalRoom.g:25680:1: ( ruleLogicalThread )
-            // InternalRoom.g:25681:1: ruleLogicalThread
+            // InternalRoom.g:25939:1: ( ruleLogicalThread )
+            // InternalRoom.g:25940:1: ruleLogicalThread
             {
              before(grammarAccess.getSubSystemClassAccess().getThreadsLogicalThreadParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69469,17 +70206,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__ConnectionsAssignment_8_2"
-    // InternalRoom.g:25690:1: rule__SubSystemClass__ConnectionsAssignment_8_2 : ( ruleLayerConnection ) ;
+    // InternalRoom.g:25949:1: rule__SubSystemClass__ConnectionsAssignment_8_2 : ( ruleLayerConnection ) ;
     public final void rule__SubSystemClass__ConnectionsAssignment_8_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25694:1: ( ( ruleLayerConnection ) )
-            // InternalRoom.g:25695:1: ( ruleLayerConnection )
+            // InternalRoom.g:25953:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25954:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25695:1: ( ruleLayerConnection )
-            // InternalRoom.g:25696:1: ruleLayerConnection
+            // InternalRoom.g:25954:1: ( ruleLayerConnection )
+            // InternalRoom.g:25955:1: ruleLayerConnection
             {
              before(grammarAccess.getSubSystemClassAccess().getConnectionsLayerConnectionParserRuleCall_8_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69510,17 +70247,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__BindingsAssignment_8_3"
-    // InternalRoom.g:25705:1: rule__SubSystemClass__BindingsAssignment_8_3 : ( ruleBinding ) ;
+    // InternalRoom.g:25964:1: rule__SubSystemClass__BindingsAssignment_8_3 : ( ruleBinding ) ;
     public final void rule__SubSystemClass__BindingsAssignment_8_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25709:1: ( ( ruleBinding ) )
-            // InternalRoom.g:25710:1: ( ruleBinding )
+            // InternalRoom.g:25968:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25969:1: ( ruleBinding )
             {
-            // InternalRoom.g:25710:1: ( ruleBinding )
-            // InternalRoom.g:25711:1: ruleBinding
+            // InternalRoom.g:25969:1: ( ruleBinding )
+            // InternalRoom.g:25970:1: ruleBinding
             {
              before(grammarAccess.getSubSystemClassAccess().getBindingsBindingParserRuleCall_8_3_0()); 
             pushFollow(FOLLOW_2);
@@ -69551,17 +70288,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__ActorRefsAssignment_8_4"
-    // InternalRoom.g:25720:1: rule__SubSystemClass__ActorRefsAssignment_8_4 : ( ruleActorRef ) ;
+    // InternalRoom.g:25979:1: rule__SubSystemClass__ActorRefsAssignment_8_4 : ( ruleActorRef ) ;
     public final void rule__SubSystemClass__ActorRefsAssignment_8_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25724:1: ( ( ruleActorRef ) )
-            // InternalRoom.g:25725:1: ( ruleActorRef )
+            // InternalRoom.g:25983:1: ( ( ruleActorRef ) )
+            // InternalRoom.g:25984:1: ( ruleActorRef )
             {
-            // InternalRoom.g:25725:1: ( ruleActorRef )
-            // InternalRoom.g:25726:1: ruleActorRef
+            // InternalRoom.g:25984:1: ( ruleActorRef )
+            // InternalRoom.g:25985:1: ruleActorRef
             {
              before(grammarAccess.getSubSystemClassAccess().getActorRefsActorRefParserRuleCall_8_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69592,17 +70329,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5"
-    // InternalRoom.g:25735:1: rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 : ( ruleSPP ) ;
+    // InternalRoom.g:25994:1: rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 : ( ruleSPP ) ;
     public final void rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25739:1: ( ( ruleSPP ) )
-            // InternalRoom.g:25740:1: ( ruleSPP )
+            // InternalRoom.g:25998:1: ( ( ruleSPP ) )
+            // InternalRoom.g:25999:1: ( ruleSPP )
             {
-            // InternalRoom.g:25740:1: ( ruleSPP )
-            // InternalRoom.g:25741:1: ruleSPP
+            // InternalRoom.g:25999:1: ( ruleSPP )
+            // InternalRoom.g:26000:1: ruleSPP
             {
              before(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsSPPParserRuleCall_8_5_0()); 
             pushFollow(FOLLOW_2);
@@ -69633,17 +70370,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__RelayPortsAssignment_8_6"
-    // InternalRoom.g:25750:1: rule__SubSystemClass__RelayPortsAssignment_8_6 : ( rulePort ) ;
+    // InternalRoom.g:26009:1: rule__SubSystemClass__RelayPortsAssignment_8_6 : ( rulePort ) ;
     public final void rule__SubSystemClass__RelayPortsAssignment_8_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25754:1: ( ( rulePort ) )
-            // InternalRoom.g:25755:1: ( rulePort )
+            // InternalRoom.g:26013:1: ( ( rulePort ) )
+            // InternalRoom.g:26014:1: ( rulePort )
             {
-            // InternalRoom.g:25755:1: ( rulePort )
-            // InternalRoom.g:25756:1: rulePort
+            // InternalRoom.g:26014:1: ( rulePort )
+            // InternalRoom.g:26015:1: rulePort
             {
              before(grammarAccess.getSubSystemClassAccess().getRelayPortsPortParserRuleCall_8_6_0()); 
             pushFollow(FOLLOW_2);
@@ -69674,17 +70411,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__NameAssignment_1"
-    // InternalRoom.g:25765:1: rule__LogicalThread__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26024:1: rule__LogicalThread__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__LogicalThread__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25769:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25770:1: ( RULE_ID )
+            // InternalRoom.g:26028:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26029:1: ( RULE_ID )
             {
-            // InternalRoom.g:25770:1: ( RULE_ID )
-            // InternalRoom.g:25771:1: RULE_ID
+            // InternalRoom.g:26029:1: ( RULE_ID )
+            // InternalRoom.g:26030:1: RULE_ID
             {
              before(grammarAccess.getLogicalThreadAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69711,17 +70448,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__PathAssignment_1"
-    // InternalRoom.g:25780:1: rule__ActorInstanceMapping__PathAssignment_1 : ( ruleRefPath ) ;
+    // InternalRoom.g:26039:1: rule__ActorInstanceMapping__PathAssignment_1 : ( ruleRefPath ) ;
     public final void rule__ActorInstanceMapping__PathAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25784:1: ( ( ruleRefPath ) )
-            // InternalRoom.g:25785:1: ( ruleRefPath )
+            // InternalRoom.g:26043:1: ( ( ruleRefPath ) )
+            // InternalRoom.g:26044:1: ( ruleRefPath )
             {
-            // InternalRoom.g:25785:1: ( ruleRefPath )
-            // InternalRoom.g:25786:1: ruleRefPath
+            // InternalRoom.g:26044:1: ( ruleRefPath )
+            // InternalRoom.g:26045:1: ruleRefPath
             {
              before(grammarAccess.getActorInstanceMappingAccess().getPathRefPathParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69752,21 +70489,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__ThreadAssignment_3"
-    // InternalRoom.g:25795:1: rule__ActorInstanceMapping__ThreadAssignment_3 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26054:1: rule__ActorInstanceMapping__ThreadAssignment_3 : ( ( RULE_ID ) ) ;
     public final void rule__ActorInstanceMapping__ThreadAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25799:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25800:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26058:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26059:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25800:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25801:1: ( RULE_ID )
+            // InternalRoom.g:26059:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26060:1: ( RULE_ID )
             {
              before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadCrossReference_3_0()); 
-            // InternalRoom.g:25802:1: ( RULE_ID )
-            // InternalRoom.g:25803:1: RULE_ID
+            // InternalRoom.g:26061:1: ( RULE_ID )
+            // InternalRoom.g:26062:1: RULE_ID
             {
              before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadIDTerminalRuleCall_3_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69797,17 +70534,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1"
-    // InternalRoom.g:25814:1: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 : ( ruleActorInstanceMapping ) ;
+    // InternalRoom.g:26073:1: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 : ( ruleActorInstanceMapping ) ;
     public final void rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25818:1: ( ( ruleActorInstanceMapping ) )
-            // InternalRoom.g:25819:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:26077:1: ( ( ruleActorInstanceMapping ) )
+            // InternalRoom.g:26078:1: ( ruleActorInstanceMapping )
             {
-            // InternalRoom.g:25819:1: ( ruleActorInstanceMapping )
-            // InternalRoom.g:25820:1: ruleActorInstanceMapping
+            // InternalRoom.g:26078:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:26079:1: ruleActorInstanceMapping
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69838,17 +70575,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__RefsAssignment_0"
-    // InternalRoom.g:25829:1: rule__RefPath__RefsAssignment_0 : ( ruleRefSegment ) ;
+    // InternalRoom.g:26088:1: rule__RefPath__RefsAssignment_0 : ( ruleRefSegment ) ;
     public final void rule__RefPath__RefsAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25833:1: ( ( ruleRefSegment ) )
-            // InternalRoom.g:25834:1: ( ruleRefSegment )
+            // InternalRoom.g:26092:1: ( ( ruleRefSegment ) )
+            // InternalRoom.g:26093:1: ( ruleRefSegment )
             {
-            // InternalRoom.g:25834:1: ( ruleRefSegment )
-            // InternalRoom.g:25835:1: ruleRefSegment
+            // InternalRoom.g:26093:1: ( ruleRefSegment )
+            // InternalRoom.g:26094:1: ruleRefSegment
             {
              before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -69879,17 +70616,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__RefsAssignment_1_1"
-    // InternalRoom.g:25844:1: rule__RefPath__RefsAssignment_1_1 : ( ruleRefSegment ) ;
+    // InternalRoom.g:26103:1: rule__RefPath__RefsAssignment_1_1 : ( ruleRefSegment ) ;
     public final void rule__RefPath__RefsAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25848:1: ( ( ruleRefSegment ) )
-            // InternalRoom.g:25849:1: ( ruleRefSegment )
+            // InternalRoom.g:26107:1: ( ( ruleRefSegment ) )
+            // InternalRoom.g:26108:1: ( ruleRefSegment )
             {
-            // InternalRoom.g:25849:1: ( ruleRefSegment )
-            // InternalRoom.g:25850:1: ruleRefSegment
+            // InternalRoom.g:26108:1: ( ruleRefSegment )
+            // InternalRoom.g:26109:1: ruleRefSegment
             {
              before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69920,17 +70657,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__RefAssignment_0"
-    // InternalRoom.g:25859:1: rule__RefSegment__RefAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:26118:1: rule__RefSegment__RefAssignment_0 : ( RULE_ID ) ;
     public final void rule__RefSegment__RefAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25863:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25864:1: ( RULE_ID )
+            // InternalRoom.g:26122:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26123:1: ( RULE_ID )
             {
-            // InternalRoom.g:25864:1: ( RULE_ID )
-            // InternalRoom.g:25865:1: RULE_ID
+            // InternalRoom.g:26123:1: ( RULE_ID )
+            // InternalRoom.g:26124:1: RULE_ID
             {
              before(grammarAccess.getRefSegmentAccess().getRefIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69957,17 +70694,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__IdxAssignment_1_1"
-    // InternalRoom.g:25874:1: rule__RefSegment__IdxAssignment_1_1 : ( RULE_INT ) ;
+    // InternalRoom.g:26133:1: rule__RefSegment__IdxAssignment_1_1 : ( RULE_INT ) ;
     public final void rule__RefSegment__IdxAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25878:1: ( ( RULE_INT ) )
-            // InternalRoom.g:25879:1: ( RULE_INT )
+            // InternalRoom.g:26137:1: ( ( RULE_INT ) )
+            // InternalRoom.g:26138:1: ( RULE_INT )
             {
-            // InternalRoom.g:25879:1: ( RULE_INT )
-            // InternalRoom.g:25880:1: RULE_INT
+            // InternalRoom.g:26138:1: ( RULE_INT )
+            // InternalRoom.g:26139:1: RULE_INT
             {
              before(grammarAccess.getRefSegmentAccess().getIdxINTTerminalRuleCall_1_1_0()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -69994,17 +70731,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Endpoint1Assignment_1"
-    // InternalRoom.g:25889:1: rule__Binding__Endpoint1Assignment_1 : ( ruleBindingEndPoint ) ;
+    // InternalRoom.g:26148:1: rule__Binding__Endpoint1Assignment_1 : ( ruleBindingEndPoint ) ;
     public final void rule__Binding__Endpoint1Assignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25893:1: ( ( ruleBindingEndPoint ) )
-            // InternalRoom.g:25894:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:26152:1: ( ( ruleBindingEndPoint ) )
+            // InternalRoom.g:26153:1: ( ruleBindingEndPoint )
             {
-            // InternalRoom.g:25894:1: ( ruleBindingEndPoint )
-            // InternalRoom.g:25895:1: ruleBindingEndPoint
+            // InternalRoom.g:26153:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:26154:1: ruleBindingEndPoint
             {
              before(grammarAccess.getBindingAccess().getEndpoint1BindingEndPointParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70035,17 +70772,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Endpoint2Assignment_3"
-    // InternalRoom.g:25904:1: rule__Binding__Endpoint2Assignment_3 : ( ruleBindingEndPoint ) ;
+    // InternalRoom.g:26163:1: rule__Binding__Endpoint2Assignment_3 : ( ruleBindingEndPoint ) ;
     public final void rule__Binding__Endpoint2Assignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25908:1: ( ( ruleBindingEndPoint ) )
-            // InternalRoom.g:25909:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:26167:1: ( ( ruleBindingEndPoint ) )
+            // InternalRoom.g:26168:1: ( ruleBindingEndPoint )
             {
-            // InternalRoom.g:25909:1: ( ruleBindingEndPoint )
-            // InternalRoom.g:25910:1: ruleBindingEndPoint
+            // InternalRoom.g:26168:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:26169:1: ruleBindingEndPoint
             {
              before(grammarAccess.getBindingAccess().getEndpoint2BindingEndPointParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70076,21 +70813,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__ActorRefAssignment_0_0"
-    // InternalRoom.g:25919:1: rule__BindingEndPoint__ActorRefAssignment_0_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26178:1: rule__BindingEndPoint__ActorRefAssignment_0_0 : ( ( RULE_ID ) ) ;
     public final void rule__BindingEndPoint__ActorRefAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25923:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25924:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26182:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26183:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25924:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25925:1: ( RULE_ID )
+            // InternalRoom.g:26183:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26184:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefCrossReference_0_0_0()); 
-            // InternalRoom.g:25926:1: ( RULE_ID )
-            // InternalRoom.g:25927:1: RULE_ID
+            // InternalRoom.g:26185:1: ( RULE_ID )
+            // InternalRoom.g:26186:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70121,21 +70858,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__PortAssignment_1"
-    // InternalRoom.g:25938:1: rule__BindingEndPoint__PortAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26197:1: rule__BindingEndPoint__PortAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__BindingEndPoint__PortAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25942:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25943:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26201:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26202:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25943:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25944:1: ( RULE_ID )
+            // InternalRoom.g:26202:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26203:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getPortPortCrossReference_1_0()); 
-            // InternalRoom.g:25945:1: ( RULE_ID )
-            // InternalRoom.g:25946:1: RULE_ID
+            // InternalRoom.g:26204:1: ( RULE_ID )
+            // InternalRoom.g:26205:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getPortPortIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70166,21 +70903,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__SubAssignment_2_1"
-    // InternalRoom.g:25957:1: rule__BindingEndPoint__SubAssignment_2_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26216:1: rule__BindingEndPoint__SubAssignment_2_1 : ( ( RULE_ID ) ) ;
     public final void rule__BindingEndPoint__SubAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25961:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:25962:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26220:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26221:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25962:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25963:1: ( RULE_ID )
+            // InternalRoom.g:26221:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26222:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolCrossReference_2_1_0()); 
-            // InternalRoom.g:25964:1: ( RULE_ID )
-            // InternalRoom.g:25965:1: RULE_ID
+            // InternalRoom.g:26223:1: ( RULE_ID )
+            // InternalRoom.g:26224:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolIDTerminalRuleCall_2_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70211,17 +70948,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__FromAssignment_1"
-    // InternalRoom.g:25976:1: rule__LayerConnection__FromAssignment_1 : ( ruleSAPoint ) ;
+    // InternalRoom.g:26235:1: rule__LayerConnection__FromAssignment_1 : ( ruleSAPoint ) ;
     public final void rule__LayerConnection__FromAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25980:1: ( ( ruleSAPoint ) )
-            // InternalRoom.g:25981:1: ( ruleSAPoint )
+            // InternalRoom.g:26239:1: ( ( ruleSAPoint ) )
+            // InternalRoom.g:26240:1: ( ruleSAPoint )
             {
-            // InternalRoom.g:25981:1: ( ruleSAPoint )
-            // InternalRoom.g:25982:1: ruleSAPoint
+            // InternalRoom.g:26240:1: ( ruleSAPoint )
+            // InternalRoom.g:26241:1: ruleSAPoint
             {
              before(grammarAccess.getLayerConnectionAccess().getFromSAPointParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70252,17 +70989,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__ToAssignment_3"
-    // InternalRoom.g:25991:1: rule__LayerConnection__ToAssignment_3 : ( ruleSPPoint ) ;
+    // InternalRoom.g:26250:1: rule__LayerConnection__ToAssignment_3 : ( ruleSPPoint ) ;
     public final void rule__LayerConnection__ToAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:25995:1: ( ( ruleSPPoint ) )
-            // InternalRoom.g:25996:1: ( ruleSPPoint )
+            // InternalRoom.g:26254:1: ( ( ruleSPPoint ) )
+            // InternalRoom.g:26255:1: ( ruleSPPoint )
             {
-            // InternalRoom.g:25996:1: ( ruleSPPoint )
-            // InternalRoom.g:25997:1: ruleSPPoint
+            // InternalRoom.g:26255:1: ( ruleSPPoint )
+            // InternalRoom.g:26256:1: ruleSPPoint
             {
              before(grammarAccess.getLayerConnectionAccess().getToSPPointParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70293,21 +71030,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__RefAssignment_1"
-    // InternalRoom.g:26006:1: rule__RefSAPoint__RefAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26265:1: rule__RefSAPoint__RefAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__RefSAPoint__RefAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26010:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:26011:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26269:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26270:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26011:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26012:1: ( RULE_ID )
+            // InternalRoom.g:26270:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26271:1: ( RULE_ID )
             {
              before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefCrossReference_1_0()); 
-            // InternalRoom.g:26013:1: ( RULE_ID )
-            // InternalRoom.g:26014:1: RULE_ID
+            // InternalRoom.g:26272:1: ( RULE_ID )
+            // InternalRoom.g:26273:1: RULE_ID
             {
              before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70338,21 +71075,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__RelayAssignment_1"
-    // InternalRoom.g:26025:1: rule__RelaySAPoint__RelayAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26284:1: rule__RelaySAPoint__RelayAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__RelaySAPoint__RelayAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26029:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:26030:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26288:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26289:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26030:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26031:1: ( RULE_ID )
+            // InternalRoom.g:26289:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26290:1: ( RULE_ID )
             {
              before(grammarAccess.getRelaySAPointAccess().getRelaySPPCrossReference_1_0()); 
-            // InternalRoom.g:26032:1: ( RULE_ID )
-            // InternalRoom.g:26033:1: RULE_ID
+            // InternalRoom.g:26291:1: ( RULE_ID )
+            // InternalRoom.g:26292:1: RULE_ID
             {
              before(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70383,21 +71120,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__RefAssignment_0"
-    // InternalRoom.g:26044:1: rule__SPPoint__RefAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26303:1: rule__SPPoint__RefAssignment_0 : ( ( RULE_ID ) ) ;
     public final void rule__SPPoint__RefAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26048:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:26049:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26307:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26308:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26049:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26050:1: ( RULE_ID )
+            // InternalRoom.g:26308:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26309:1: ( RULE_ID )
             {
              before(grammarAccess.getSPPointAccess().getRefActorContainerRefCrossReference_0_0()); 
-            // InternalRoom.g:26051:1: ( RULE_ID )
-            // InternalRoom.g:26052:1: RULE_ID
+            // InternalRoom.g:26310:1: ( RULE_ID )
+            // InternalRoom.g:26311:1: RULE_ID
             {
              before(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70428,21 +71165,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__ServiceAssignment_2"
-    // InternalRoom.g:26063:1: rule__SPPoint__ServiceAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26322:1: rule__SPPoint__ServiceAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__SPPoint__ServiceAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26067:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:26068:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26326:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26327:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26068:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26069:1: ( RULE_ID )
+            // InternalRoom.g:26327:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26328:1: ( RULE_ID )
             {
              before(grammarAccess.getSPPointAccess().getServiceSPPCrossReference_2_0()); 
-            // InternalRoom.g:26070:1: ( RULE_ID )
-            // InternalRoom.g:26071:1: RULE_ID
+            // InternalRoom.g:26329:1: ( RULE_ID )
+            // InternalRoom.g:26330:1: RULE_ID
             {
              before(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70473,17 +71210,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__RefTypeAssignment_0"
-    // InternalRoom.g:26082:1: rule__ActorRef__RefTypeAssignment_0 : ( ruleReferenceType ) ;
+    // InternalRoom.g:26341:1: rule__ActorRef__RefTypeAssignment_0 : ( ruleReferenceType ) ;
     public final void rule__ActorRef__RefTypeAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26086:1: ( ( ruleReferenceType ) )
-            // InternalRoom.g:26087:1: ( ruleReferenceType )
+            // InternalRoom.g:26345:1: ( ( ruleReferenceType ) )
+            // InternalRoom.g:26346:1: ( ruleReferenceType )
             {
-            // InternalRoom.g:26087:1: ( ruleReferenceType )
-            // InternalRoom.g:26088:1: ruleReferenceType
+            // InternalRoom.g:26346:1: ( ruleReferenceType )
+            // InternalRoom.g:26347:1: ruleReferenceType
             {
              before(grammarAccess.getActorRefAccess().getRefTypeReferenceTypeEnumRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70514,17 +71251,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__NameAssignment_2"
-    // InternalRoom.g:26097:1: rule__ActorRef__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:26356:1: rule__ActorRef__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__ActorRef__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26101:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26102:1: ( RULE_ID )
+            // InternalRoom.g:26360:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26361:1: ( RULE_ID )
             {
-            // InternalRoom.g:26102:1: ( RULE_ID )
-            // InternalRoom.g:26103:1: RULE_ID
+            // InternalRoom.g:26361:1: ( RULE_ID )
+            // InternalRoom.g:26362:1: RULE_ID
             {
              before(grammarAccess.getActorRefAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70551,17 +71288,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__MultiplicityAssignment_3"
-    // InternalRoom.g:26112:1: rule__ActorRef__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
+    // InternalRoom.g:26371:1: rule__ActorRef__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
     public final void rule__ActorRef__MultiplicityAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26116:1: ( ( ruleMULTIPLICITY ) )
-            // InternalRoom.g:26117:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:26375:1: ( ( ruleMULTIPLICITY ) )
+            // InternalRoom.g:26376:1: ( ruleMULTIPLICITY )
             {
-            // InternalRoom.g:26117:1: ( ruleMULTIPLICITY )
-            // InternalRoom.g:26118:1: ruleMULTIPLICITY
+            // InternalRoom.g:26376:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:26377:1: ruleMULTIPLICITY
             {
              before(grammarAccess.getActorRefAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70592,21 +71329,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__TypeAssignment_5"
-    // InternalRoom.g:26127:1: rule__ActorRef__TypeAssignment_5 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:26386:1: rule__ActorRef__TypeAssignment_5 : ( ( ruleFQN ) ) ;
     public final void rule__ActorRef__TypeAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26131:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:26132:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26390:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:26391:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:26132:1: ( ( ruleFQN ) )
-            // InternalRoom.g:26133:1: ( ruleFQN )
+            // InternalRoom.g:26391:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26392:1: ( ruleFQN )
             {
              before(grammarAccess.getActorRefAccess().getTypeActorClassCrossReference_5_0()); 
-            // InternalRoom.g:26134:1: ( ruleFQN )
-            // InternalRoom.g:26135:1: ruleFQN
+            // InternalRoom.g:26393:1: ( ruleFQN )
+            // InternalRoom.g:26394:1: ruleFQN
             {
              before(grammarAccess.getActorRefAccess().getTypeActorClassFQNParserRuleCall_5_0_1()); 
             pushFollow(FOLLOW_2);
@@ -70641,17 +71378,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__DocuAssignment_6"
-    // InternalRoom.g:26146:1: rule__ActorRef__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26405:1: rule__ActorRef__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__ActorRef__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26150:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26151:1: ( ruleDocumentation )
+            // InternalRoom.g:26409:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26410:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26151:1: ( ruleDocumentation )
-            // InternalRoom.g:26152:1: ruleDocumentation
+            // InternalRoom.g:26410:1: ( ruleDocumentation )
+            // InternalRoom.g:26411:1: ruleDocumentation
             {
              before(grammarAccess.getActorRefAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -70682,17 +71419,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__StatesAssignment_2_0"
-    // InternalRoom.g:26162:1: rule__StateGraph__StatesAssignment_2_0 : ( ruleState ) ;
+    // InternalRoom.g:26421:1: rule__StateGraph__StatesAssignment_2_0 : ( ruleState ) ;
     public final void rule__StateGraph__StatesAssignment_2_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26166:1: ( ( ruleState ) )
-            // InternalRoom.g:26167:1: ( ruleState )
+            // InternalRoom.g:26425:1: ( ( ruleState ) )
+            // InternalRoom.g:26426:1: ( ruleState )
             {
-            // InternalRoom.g:26167:1: ( ruleState )
-            // InternalRoom.g:26168:1: ruleState
+            // InternalRoom.g:26426:1: ( ruleState )
+            // InternalRoom.g:26427:1: ruleState
             {
              before(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70723,17 +71460,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__TrPointsAssignment_2_1"
-    // InternalRoom.g:26177:1: rule__StateGraph__TrPointsAssignment_2_1 : ( ruleTrPoint ) ;
+    // InternalRoom.g:26436:1: rule__StateGraph__TrPointsAssignment_2_1 : ( ruleTrPoint ) ;
     public final void rule__StateGraph__TrPointsAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26181:1: ( ( ruleTrPoint ) )
-            // InternalRoom.g:26182:1: ( ruleTrPoint )
+            // InternalRoom.g:26440:1: ( ( ruleTrPoint ) )
+            // InternalRoom.g:26441:1: ( ruleTrPoint )
             {
-            // InternalRoom.g:26182:1: ( ruleTrPoint )
-            // InternalRoom.g:26183:1: ruleTrPoint
+            // InternalRoom.g:26441:1: ( ruleTrPoint )
+            // InternalRoom.g:26442:1: ruleTrPoint
             {
              before(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70764,17 +71501,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__ChPointsAssignment_2_2"
-    // InternalRoom.g:26192:1: rule__StateGraph__ChPointsAssignment_2_2 : ( ruleChoicePoint ) ;
+    // InternalRoom.g:26451:1: rule__StateGraph__ChPointsAssignment_2_2 : ( ruleChoicePoint ) ;
     public final void rule__StateGraph__ChPointsAssignment_2_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26196:1: ( ( ruleChoicePoint ) )
-            // InternalRoom.g:26197:1: ( ruleChoicePoint )
+            // InternalRoom.g:26455:1: ( ( ruleChoicePoint ) )
+            // InternalRoom.g:26456:1: ( ruleChoicePoint )
             {
-            // InternalRoom.g:26197:1: ( ruleChoicePoint )
-            // InternalRoom.g:26198:1: ruleChoicePoint
+            // InternalRoom.g:26456:1: ( ruleChoicePoint )
+            // InternalRoom.g:26457:1: ruleChoicePoint
             {
              before(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); 
             pushFollow(FOLLOW_2);
@@ -70805,17 +71542,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__TransitionsAssignment_2_3"
-    // InternalRoom.g:26207:1: rule__StateGraph__TransitionsAssignment_2_3 : ( ruleTransition ) ;
+    // InternalRoom.g:26466:1: rule__StateGraph__TransitionsAssignment_2_3 : ( ruleTransition ) ;
     public final void rule__StateGraph__TransitionsAssignment_2_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26211:1: ( ( ruleTransition ) )
-            // InternalRoom.g:26212:1: ( ruleTransition )
+            // InternalRoom.g:26470:1: ( ( ruleTransition ) )
+            // InternalRoom.g:26471:1: ( ruleTransition )
             {
-            // InternalRoom.g:26212:1: ( ruleTransition )
-            // InternalRoom.g:26213:1: ruleTransition
+            // InternalRoom.g:26471:1: ( ruleTransition )
+            // InternalRoom.g:26472:1: ruleTransition
             {
              before(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70846,17 +71583,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__RefinedTransitionsAssignment_2_4"
-    // InternalRoom.g:26222:1: rule__StateGraph__RefinedTransitionsAssignment_2_4 : ( ruleRefinedTransition ) ;
+    // InternalRoom.g:26481:1: rule__StateGraph__RefinedTransitionsAssignment_2_4 : ( ruleRefinedTransition ) ;
     public final void rule__StateGraph__RefinedTransitionsAssignment_2_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26226:1: ( ( ruleRefinedTransition ) )
-            // InternalRoom.g:26227:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26485:1: ( ( ruleRefinedTransition ) )
+            // InternalRoom.g:26486:1: ( ruleRefinedTransition )
             {
-            // InternalRoom.g:26227:1: ( ruleRefinedTransition )
-            // InternalRoom.g:26228:1: ruleRefinedTransition
+            // InternalRoom.g:26486:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26487:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); 
             pushFollow(FOLLOW_2);
@@ -70887,17 +71624,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__StatesAssignment_3_0"
-    // InternalRoom.g:26237:1: rule__StateMachine__StatesAssignment_3_0 : ( ruleState ) ;
+    // InternalRoom.g:26496:1: rule__StateMachine__StatesAssignment_3_0 : ( ruleState ) ;
     public final void rule__StateMachine__StatesAssignment_3_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26241:1: ( ( ruleState ) )
-            // InternalRoom.g:26242:1: ( ruleState )
+            // InternalRoom.g:26500:1: ( ( ruleState ) )
+            // InternalRoom.g:26501:1: ( ruleState )
             {
-            // InternalRoom.g:26242:1: ( ruleState )
-            // InternalRoom.g:26243:1: ruleState
+            // InternalRoom.g:26501:1: ( ruleState )
+            // InternalRoom.g:26502:1: ruleState
             {
              before(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70928,17 +71665,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__TrPointsAssignment_3_1"
-    // InternalRoom.g:26252:1: rule__StateMachine__TrPointsAssignment_3_1 : ( ruleTrPoint ) ;
+    // InternalRoom.g:26511:1: rule__StateMachine__TrPointsAssignment_3_1 : ( ruleTrPoint ) ;
     public final void rule__StateMachine__TrPointsAssignment_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26256:1: ( ( ruleTrPoint ) )
-            // InternalRoom.g:26257:1: ( ruleTrPoint )
+            // InternalRoom.g:26515:1: ( ( ruleTrPoint ) )
+            // InternalRoom.g:26516:1: ( ruleTrPoint )
             {
-            // InternalRoom.g:26257:1: ( ruleTrPoint )
-            // InternalRoom.g:26258:1: ruleTrPoint
+            // InternalRoom.g:26516:1: ( ruleTrPoint )
+            // InternalRoom.g:26517:1: ruleTrPoint
             {
              before(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70969,17 +71706,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__ChPointsAssignment_3_2"
-    // InternalRoom.g:26267:1: rule__StateMachine__ChPointsAssignment_3_2 : ( ruleChoicePoint ) ;
+    // InternalRoom.g:26526:1: rule__StateMachine__ChPointsAssignment_3_2 : ( ruleChoicePoint ) ;
     public final void rule__StateMachine__ChPointsAssignment_3_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26271:1: ( ( ruleChoicePoint ) )
-            // InternalRoom.g:26272:1: ( ruleChoicePoint )
+            // InternalRoom.g:26530:1: ( ( ruleChoicePoint ) )
+            // InternalRoom.g:26531:1: ( ruleChoicePoint )
             {
-            // InternalRoom.g:26272:1: ( ruleChoicePoint )
-            // InternalRoom.g:26273:1: ruleChoicePoint
+            // InternalRoom.g:26531:1: ( ruleChoicePoint )
+            // InternalRoom.g:26532:1: ruleChoicePoint
             {
              before(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71010,17 +71747,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__TransitionsAssignment_3_3"
-    // InternalRoom.g:26282:1: rule__StateMachine__TransitionsAssignment_3_3 : ( ruleTransition ) ;
+    // InternalRoom.g:26541:1: rule__StateMachine__TransitionsAssignment_3_3 : ( ruleTransition ) ;
     public final void rule__StateMachine__TransitionsAssignment_3_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26286:1: ( ( ruleTransition ) )
-            // InternalRoom.g:26287:1: ( ruleTransition )
+            // InternalRoom.g:26545:1: ( ( ruleTransition ) )
+            // InternalRoom.g:26546:1: ( ruleTransition )
             {
-            // InternalRoom.g:26287:1: ( ruleTransition )
-            // InternalRoom.g:26288:1: ruleTransition
+            // InternalRoom.g:26546:1: ( ruleTransition )
+            // InternalRoom.g:26547:1: ruleTransition
             {
              before(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); 
             pushFollow(FOLLOW_2);
@@ -71051,17 +71788,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__RefinedTransitionsAssignment_3_4"
-    // InternalRoom.g:26297:1: rule__StateMachine__RefinedTransitionsAssignment_3_4 : ( ruleRefinedTransition ) ;
+    // InternalRoom.g:26556:1: rule__StateMachine__RefinedTransitionsAssignment_3_4 : ( ruleRefinedTransition ) ;
     public final void rule__StateMachine__RefinedTransitionsAssignment_3_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26301:1: ( ( ruleRefinedTransition ) )
-            // InternalRoom.g:26302:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26560:1: ( ( ruleRefinedTransition ) )
+            // InternalRoom.g:26561:1: ( ruleRefinedTransition )
             {
-            // InternalRoom.g:26302:1: ( ruleRefinedTransition )
-            // InternalRoom.g:26303:1: ruleRefinedTransition
+            // InternalRoom.g:26561:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26562:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); 
             pushFollow(FOLLOW_2);
@@ -71092,17 +71829,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__NameAssignment_1"
-    // InternalRoom.g:26312:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26571:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__SimpleState__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26316:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26317:1: ( RULE_ID )
+            // InternalRoom.g:26575:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26576:1: ( RULE_ID )
             {
-            // InternalRoom.g:26317:1: ( RULE_ID )
-            // InternalRoom.g:26318:1: RULE_ID
+            // InternalRoom.g:26576:1: ( RULE_ID )
+            // InternalRoom.g:26577:1: RULE_ID
             {
              before(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71129,17 +71866,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__DocuAssignment_2"
-    // InternalRoom.g:26327:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26586:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__SimpleState__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26331:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26332:1: ( ruleDocumentation )
+            // InternalRoom.g:26590:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26591:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26332:1: ( ruleDocumentation )
-            // InternalRoom.g:26333:1: ruleDocumentation
+            // InternalRoom.g:26591:1: ( ruleDocumentation )
+            // InternalRoom.g:26592:1: ruleDocumentation
             {
              before(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71170,17 +71907,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__EntryCodeAssignment_3_1_1"
-    // InternalRoom.g:26342:1: rule__SimpleState__EntryCodeAssignment_3_1_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26601:1: rule__SimpleState__EntryCodeAssignment_3_1_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__EntryCodeAssignment_3_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26346:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26347:1: ( ruleDetailCode )
+            // InternalRoom.g:26605:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26606:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26347:1: ( ruleDetailCode )
-            // InternalRoom.g:26348:1: ruleDetailCode
+            // InternalRoom.g:26606:1: ( ruleDetailCode )
+            // InternalRoom.g:26607:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71211,17 +71948,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__ExitCodeAssignment_3_2_1"
-    // InternalRoom.g:26357:1: rule__SimpleState__ExitCodeAssignment_3_2_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26616:1: rule__SimpleState__ExitCodeAssignment_3_2_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__ExitCodeAssignment_3_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26361:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26362:1: ( ruleDetailCode )
+            // InternalRoom.g:26620:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26621:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26362:1: ( ruleDetailCode )
-            // InternalRoom.g:26363:1: ruleDetailCode
+            // InternalRoom.g:26621:1: ( ruleDetailCode )
+            // InternalRoom.g:26622:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71252,17 +71989,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__DoCodeAssignment_3_3_1"
-    // InternalRoom.g:26372:1: rule__SimpleState__DoCodeAssignment_3_3_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26631:1: rule__SimpleState__DoCodeAssignment_3_3_1 : ( ruleDetailCode ) ;
     public final void rule__SimpleState__DoCodeAssignment_3_3_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26376:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26377:1: ( ruleDetailCode )
+            // InternalRoom.g:26635:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26636:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26377:1: ( ruleDetailCode )
-            // InternalRoom.g:26378:1: ruleDetailCode
+            // InternalRoom.g:26636:1: ( ruleDetailCode )
+            // InternalRoom.g:26637:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71293,17 +72030,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__SubgraphAssignment_3_4_1"
-    // InternalRoom.g:26387:1: rule__SimpleState__SubgraphAssignment_3_4_1 : ( ruleStateGraph ) ;
+    // InternalRoom.g:26646:1: rule__SimpleState__SubgraphAssignment_3_4_1 : ( ruleStateGraph ) ;
     public final void rule__SimpleState__SubgraphAssignment_3_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26391:1: ( ( ruleStateGraph ) )
-            // InternalRoom.g:26392:1: ( ruleStateGraph )
+            // InternalRoom.g:26650:1: ( ( ruleStateGraph ) )
+            // InternalRoom.g:26651:1: ( ruleStateGraph )
             {
-            // InternalRoom.g:26392:1: ( ruleStateGraph )
-            // InternalRoom.g:26393:1: ruleStateGraph
+            // InternalRoom.g:26651:1: ( ruleStateGraph )
+            // InternalRoom.g:26652:1: ruleStateGraph
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71334,21 +72071,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__TargetAssignment_1"
-    // InternalRoom.g:26402:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:26661:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ;
     public final void rule__RefinedState__TargetAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26406:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:26407:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26665:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:26666:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:26407:1: ( ( ruleFQN ) )
-            // InternalRoom.g:26408:1: ( ruleFQN )
+            // InternalRoom.g:26666:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26667:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); 
-            // InternalRoom.g:26409:1: ( ruleFQN )
-            // InternalRoom.g:26410:1: ruleFQN
+            // InternalRoom.g:26668:1: ( ruleFQN )
+            // InternalRoom.g:26669:1: ruleFQN
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -71383,17 +72120,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__DocuAssignment_2"
-    // InternalRoom.g:26421:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26680:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__RefinedState__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26425:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26426:1: ( ruleDocumentation )
+            // InternalRoom.g:26684:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26685:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26426:1: ( ruleDocumentation )
-            // InternalRoom.g:26427:1: ruleDocumentation
+            // InternalRoom.g:26685:1: ( ruleDocumentation )
+            // InternalRoom.g:26686:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71424,17 +72161,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__EntryCodeAssignment_4_1"
-    // InternalRoom.g:26436:1: rule__RefinedState__EntryCodeAssignment_4_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26695:1: rule__RefinedState__EntryCodeAssignment_4_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__EntryCodeAssignment_4_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26440:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26441:1: ( ruleDetailCode )
+            // InternalRoom.g:26699:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26700:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26441:1: ( ruleDetailCode )
-            // InternalRoom.g:26442:1: ruleDetailCode
+            // InternalRoom.g:26700:1: ( ruleDetailCode )
+            // InternalRoom.g:26701:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71465,17 +72202,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__ExitCodeAssignment_5_1"
-    // InternalRoom.g:26451:1: rule__RefinedState__ExitCodeAssignment_5_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26710:1: rule__RefinedState__ExitCodeAssignment_5_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__ExitCodeAssignment_5_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26455:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26456:1: ( ruleDetailCode )
+            // InternalRoom.g:26714:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26715:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26456:1: ( ruleDetailCode )
-            // InternalRoom.g:26457:1: ruleDetailCode
+            // InternalRoom.g:26715:1: ( ruleDetailCode )
+            // InternalRoom.g:26716:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71506,17 +72243,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__DoCodeAssignment_6_1"
-    // InternalRoom.g:26466:1: rule__RefinedState__DoCodeAssignment_6_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26725:1: rule__RefinedState__DoCodeAssignment_6_1 : ( ruleDetailCode ) ;
     public final void rule__RefinedState__DoCodeAssignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26470:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26471:1: ( ruleDetailCode )
+            // InternalRoom.g:26729:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26730:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26471:1: ( ruleDetailCode )
-            // InternalRoom.g:26472:1: ruleDetailCode
+            // InternalRoom.g:26730:1: ( ruleDetailCode )
+            // InternalRoom.g:26731:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71547,17 +72284,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__SubgraphAssignment_7_1"
-    // InternalRoom.g:26481:1: rule__RefinedState__SubgraphAssignment_7_1 : ( ruleStateGraph ) ;
+    // InternalRoom.g:26740:1: rule__RefinedState__SubgraphAssignment_7_1 : ( ruleStateGraph ) ;
     public final void rule__RefinedState__SubgraphAssignment_7_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26485:1: ( ( ruleStateGraph ) )
-            // InternalRoom.g:26486:1: ( ruleStateGraph )
+            // InternalRoom.g:26744:1: ( ( ruleStateGraph ) )
+            // InternalRoom.g:26745:1: ( ruleStateGraph )
             {
-            // InternalRoom.g:26486:1: ( ruleStateGraph )
-            // InternalRoom.g:26487:1: ruleStateGraph
+            // InternalRoom.g:26745:1: ( ruleStateGraph )
+            // InternalRoom.g:26746:1: ruleStateGraph
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71588,17 +72325,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__LinesAssignment_0_1"
-    // InternalRoom.g:26496:1: rule__DetailCode__LinesAssignment_0_1 : ( RULE_CC_STRING ) ;
+    // InternalRoom.g:26755:1: rule__DetailCode__LinesAssignment_0_1 : ( RULE_CC_STRING ) ;
     public final void rule__DetailCode__LinesAssignment_0_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26500:1: ( ( RULE_CC_STRING ) )
-            // InternalRoom.g:26501:1: ( RULE_CC_STRING )
+            // InternalRoom.g:26759:1: ( ( RULE_CC_STRING ) )
+            // InternalRoom.g:26760:1: ( RULE_CC_STRING )
             {
-            // InternalRoom.g:26501:1: ( RULE_CC_STRING )
-            // InternalRoom.g:26502:1: RULE_CC_STRING
+            // InternalRoom.g:26760:1: ( RULE_CC_STRING )
+            // InternalRoom.g:26761:1: RULE_CC_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesCC_STRINGTerminalRuleCall_0_1_0()); 
             match(input,RULE_CC_STRING,FOLLOW_2); 
@@ -71625,21 +72362,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__UsedAssignment_1_0"
-    // InternalRoom.g:26511:1: rule__DetailCode__UsedAssignment_1_0 : ( ( '{' ) ) ;
+    // InternalRoom.g:26770:1: rule__DetailCode__UsedAssignment_1_0 : ( ( '{' ) ) ;
     public final void rule__DetailCode__UsedAssignment_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26515:1: ( ( ( '{' ) ) )
-            // InternalRoom.g:26516:1: ( ( '{' ) )
+            // InternalRoom.g:26774:1: ( ( ( '{' ) ) )
+            // InternalRoom.g:26775:1: ( ( '{' ) )
             {
-            // InternalRoom.g:26516:1: ( ( '{' ) )
-            // InternalRoom.g:26517:1: ( '{' )
+            // InternalRoom.g:26775:1: ( ( '{' ) )
+            // InternalRoom.g:26776:1: ( '{' )
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
-            // InternalRoom.g:26518:1: ( '{' )
-            // InternalRoom.g:26519:1: '{'
+            // InternalRoom.g:26777:1: ( '{' )
+            // InternalRoom.g:26778:1: '{'
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
             match(input,44,FOLLOW_2); 
@@ -71670,17 +72407,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__LinesAssignment_1_1"
-    // InternalRoom.g:26534:1: rule__DetailCode__LinesAssignment_1_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:26793:1: rule__DetailCode__LinesAssignment_1_1 : ( RULE_STRING ) ;
     public final void rule__DetailCode__LinesAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26538:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:26539:1: ( RULE_STRING )
+            // InternalRoom.g:26797:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:26798:1: ( RULE_STRING )
             {
-            // InternalRoom.g:26539:1: ( RULE_STRING )
-            // InternalRoom.g:26540:1: RULE_STRING
+            // InternalRoom.g:26798:1: ( RULE_STRING )
+            // InternalRoom.g:26799:1: RULE_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_1_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -71707,21 +72444,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__HandlerAssignment_0"
-    // InternalRoom.g:26549:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ;
+    // InternalRoom.g:26808:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ;
     public final void rule__TransitionPoint__HandlerAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26553:1: ( ( ( 'handler' ) ) )
-            // InternalRoom.g:26554:1: ( ( 'handler' ) )
+            // InternalRoom.g:26812:1: ( ( ( 'handler' ) ) )
+            // InternalRoom.g:26813:1: ( ( 'handler' ) )
             {
-            // InternalRoom.g:26554:1: ( ( 'handler' ) )
-            // InternalRoom.g:26555:1: ( 'handler' )
+            // InternalRoom.g:26813:1: ( ( 'handler' ) )
+            // InternalRoom.g:26814:1: ( 'handler' )
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
-            // InternalRoom.g:26556:1: ( 'handler' )
-            // InternalRoom.g:26557:1: 'handler'
+            // InternalRoom.g:26815:1: ( 'handler' )
+            // InternalRoom.g:26816:1: 'handler'
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
             match(input,131,FOLLOW_2); 
@@ -71752,17 +72489,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__NameAssignment_2"
-    // InternalRoom.g:26572:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:26831:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__TransitionPoint__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26576:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26577:1: ( RULE_ID )
+            // InternalRoom.g:26835:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26836:1: ( RULE_ID )
             {
-            // InternalRoom.g:26577:1: ( RULE_ID )
-            // InternalRoom.g:26578:1: RULE_ID
+            // InternalRoom.g:26836:1: ( RULE_ID )
+            // InternalRoom.g:26837:1: RULE_ID
             {
              before(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71789,17 +72526,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__NameAssignment_1"
-    // InternalRoom.g:26587:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26846:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__EntryPoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26591:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26592:1: ( RULE_ID )
+            // InternalRoom.g:26850:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26851:1: ( RULE_ID )
             {
-            // InternalRoom.g:26592:1: ( RULE_ID )
-            // InternalRoom.g:26593:1: RULE_ID
+            // InternalRoom.g:26851:1: ( RULE_ID )
+            // InternalRoom.g:26852:1: RULE_ID
             {
              before(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71826,17 +72563,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__NameAssignment_1"
-    // InternalRoom.g:26602:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26861:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ExitPoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26606:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26607:1: ( RULE_ID )
+            // InternalRoom.g:26865:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26866:1: ( RULE_ID )
             {
-            // InternalRoom.g:26607:1: ( RULE_ID )
-            // InternalRoom.g:26608:1: RULE_ID
+            // InternalRoom.g:26866:1: ( RULE_ID )
+            // InternalRoom.g:26867:1: RULE_ID
             {
              before(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71863,17 +72600,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__NameAssignment_1"
-    // InternalRoom.g:26617:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26876:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ChoicePoint__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26621:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26622:1: ( RULE_ID )
+            // InternalRoom.g:26880:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26881:1: ( RULE_ID )
             {
-            // InternalRoom.g:26622:1: ( RULE_ID )
-            // InternalRoom.g:26623:1: RULE_ID
+            // InternalRoom.g:26881:1: ( RULE_ID )
+            // InternalRoom.g:26882:1: RULE_ID
             {
              before(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71900,17 +72637,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__DocuAssignment_2"
-    // InternalRoom.g:26632:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26891:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__ChoicePoint__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26636:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26637:1: ( ruleDocumentation )
+            // InternalRoom.g:26895:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26896:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26637:1: ( ruleDocumentation )
-            // InternalRoom.g:26638:1: ruleDocumentation
+            // InternalRoom.g:26896:1: ( ruleDocumentation )
+            // InternalRoom.g:26897:1: ruleDocumentation
             {
              before(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71941,17 +72678,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__NameAssignment_1"
-    // InternalRoom.g:26647:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26906:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__InitialTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26651:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26652:1: ( RULE_ID )
+            // InternalRoom.g:26910:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26911:1: ( RULE_ID )
             {
-            // InternalRoom.g:26652:1: ( RULE_ID )
-            // InternalRoom.g:26653:1: RULE_ID
+            // InternalRoom.g:26911:1: ( RULE_ID )
+            // InternalRoom.g:26912:1: RULE_ID
             {
              before(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71978,17 +72715,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__ToAssignment_5"
-    // InternalRoom.g:26662:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26921:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__InitialTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26666:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26667:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26925:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26926:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26667:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26668:1: ruleTransitionTerminal
+            // InternalRoom.g:26926:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26927:1: ruleTransitionTerminal
             {
              before(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72019,17 +72756,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__DocuAssignment_6"
-    // InternalRoom.g:26677:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26936:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__InitialTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26681:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26682:1: ( ruleDocumentation )
+            // InternalRoom.g:26940:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26941:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26682:1: ( ruleDocumentation )
-            // InternalRoom.g:26683:1: ruleDocumentation
+            // InternalRoom.g:26941:1: ( ruleDocumentation )
+            // InternalRoom.g:26942:1: ruleDocumentation
             {
              before(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72060,17 +72797,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__ActionAssignment_7_1_1"
-    // InternalRoom.g:26692:1: rule__InitialTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26951:1: rule__InitialTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
     public final void rule__InitialTransition__ActionAssignment_7_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26696:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26697:1: ( ruleDetailCode )
+            // InternalRoom.g:26955:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26956:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26697:1: ( ruleDetailCode )
-            // InternalRoom.g:26698:1: ruleDetailCode
+            // InternalRoom.g:26956:1: ( ruleDetailCode )
+            // InternalRoom.g:26957:1: ruleDetailCode
             {
              before(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72101,17 +72838,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__NameAssignment_1"
-    // InternalRoom.g:26707:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26966:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__ContinuationTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26711:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26712:1: ( RULE_ID )
+            // InternalRoom.g:26970:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26971:1: ( RULE_ID )
             {
-            // InternalRoom.g:26712:1: ( RULE_ID )
-            // InternalRoom.g:26713:1: RULE_ID
+            // InternalRoom.g:26971:1: ( RULE_ID )
+            // InternalRoom.g:26972:1: RULE_ID
             {
              before(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72138,17 +72875,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__FromAssignment_3"
-    // InternalRoom.g:26722:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26981:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__ContinuationTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26726:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26727:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26985:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26986:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26727:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26728:1: ruleTransitionTerminal
+            // InternalRoom.g:26986:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26987:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72179,17 +72916,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__ToAssignment_5"
-    // InternalRoom.g:26737:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26996:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__ContinuationTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26741:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26742:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27000:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27001:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26742:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26743:1: ruleTransitionTerminal
+            // InternalRoom.g:27001:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27002:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72220,17 +72957,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__DocuAssignment_6"
-    // InternalRoom.g:26752:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27011:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__ContinuationTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26756:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26757:1: ( ruleDocumentation )
+            // InternalRoom.g:27015:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27016:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26757:1: ( ruleDocumentation )
-            // InternalRoom.g:26758:1: ruleDocumentation
+            // InternalRoom.g:27016:1: ( ruleDocumentation )
+            // InternalRoom.g:27017:1: ruleDocumentation
             {
              before(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72261,17 +72998,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__ActionAssignment_7_1_1"
-    // InternalRoom.g:26767:1: rule__ContinuationTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27026:1: rule__ContinuationTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ;
     public final void rule__ContinuationTransition__ActionAssignment_7_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26771:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26772:1: ( ruleDetailCode )
+            // InternalRoom.g:27030:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27031:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26772:1: ( ruleDetailCode )
-            // InternalRoom.g:26773:1: ruleDetailCode
+            // InternalRoom.g:27031:1: ( ruleDetailCode )
+            // InternalRoom.g:27032:1: ruleDetailCode
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72302,17 +73039,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__NameAssignment_1"
-    // InternalRoom.g:26782:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27041:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__TriggeredTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26786:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26787:1: ( RULE_ID )
+            // InternalRoom.g:27045:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27046:1: ( RULE_ID )
             {
-            // InternalRoom.g:26787:1: ( RULE_ID )
-            // InternalRoom.g:26788:1: RULE_ID
+            // InternalRoom.g:27046:1: ( RULE_ID )
+            // InternalRoom.g:27047:1: RULE_ID
             {
              before(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72339,17 +73076,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__FromAssignment_3"
-    // InternalRoom.g:26797:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27056:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__TriggeredTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26801:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26802:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27060:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27061:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26802:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26803:1: ruleTransitionTerminal
+            // InternalRoom.g:27061:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27062:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72380,17 +73117,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__ToAssignment_5"
-    // InternalRoom.g:26812:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27071:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__TriggeredTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26816:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26817:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27075:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27076:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26817:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26818:1: ruleTransitionTerminal
+            // InternalRoom.g:27076:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27077:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72421,17 +73158,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__DocuAssignment_6"
-    // InternalRoom.g:26827:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27086:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__TriggeredTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26831:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26832:1: ( ruleDocumentation )
+            // InternalRoom.g:27090:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27091:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26832:1: ( ruleDocumentation )
-            // InternalRoom.g:26833:1: ruleDocumentation
+            // InternalRoom.g:27091:1: ( ruleDocumentation )
+            // InternalRoom.g:27092:1: ruleDocumentation
             {
              before(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72462,17 +73199,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_10"
-    // InternalRoom.g:26842:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ;
+    // InternalRoom.g:27101:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ;
     public final void rule__TriggeredTransition__TriggersAssignment_10() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26846:1: ( ( ruleTrigger ) )
-            // InternalRoom.g:26847:1: ( ruleTrigger )
+            // InternalRoom.g:27105:1: ( ( ruleTrigger ) )
+            // InternalRoom.g:27106:1: ( ruleTrigger )
             {
-            // InternalRoom.g:26847:1: ( ruleTrigger )
-            // InternalRoom.g:26848:1: ruleTrigger
+            // InternalRoom.g:27106:1: ( ruleTrigger )
+            // InternalRoom.g:27107:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
             pushFollow(FOLLOW_2);
@@ -72503,17 +73240,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_11_1"
-    // InternalRoom.g:26857:1: rule__TriggeredTransition__TriggersAssignment_11_1 : ( ruleTrigger ) ;
+    // InternalRoom.g:27116:1: rule__TriggeredTransition__TriggersAssignment_11_1 : ( ruleTrigger ) ;
     public final void rule__TriggeredTransition__TriggersAssignment_11_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26861:1: ( ( ruleTrigger ) )
-            // InternalRoom.g:26862:1: ( ruleTrigger )
+            // InternalRoom.g:27120:1: ( ( ruleTrigger ) )
+            // InternalRoom.g:27121:1: ( ruleTrigger )
             {
-            // InternalRoom.g:26862:1: ( ruleTrigger )
-            // InternalRoom.g:26863:1: ruleTrigger
+            // InternalRoom.g:27121:1: ( ruleTrigger )
+            // InternalRoom.g:27122:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72544,17 +73281,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__ActionAssignment_13_1"
-    // InternalRoom.g:26872:1: rule__TriggeredTransition__ActionAssignment_13_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27131:1: rule__TriggeredTransition__ActionAssignment_13_1 : ( ruleDetailCode ) ;
     public final void rule__TriggeredTransition__ActionAssignment_13_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26876:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26877:1: ( ruleDetailCode )
+            // InternalRoom.g:27135:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27136:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26877:1: ( ruleDetailCode )
-            // InternalRoom.g:26878:1: ruleDetailCode
+            // InternalRoom.g:27136:1: ( ruleDetailCode )
+            // InternalRoom.g:27137:1: ruleDetailCode
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72585,17 +73322,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__NameAssignment_1"
-    // InternalRoom.g:26887:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27146:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__GuardedTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26891:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26892:1: ( RULE_ID )
+            // InternalRoom.g:27150:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27151:1: ( RULE_ID )
             {
-            // InternalRoom.g:26892:1: ( RULE_ID )
-            // InternalRoom.g:26893:1: RULE_ID
+            // InternalRoom.g:27151:1: ( RULE_ID )
+            // InternalRoom.g:27152:1: RULE_ID
             {
              before(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72622,17 +73359,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__FromAssignment_3"
-    // InternalRoom.g:26902:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27161:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__GuardedTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26906:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26907:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27165:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27166:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26907:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26908:1: ruleTransitionTerminal
+            // InternalRoom.g:27166:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27167:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72663,17 +73400,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__ToAssignment_5"
-    // InternalRoom.g:26917:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27176:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__GuardedTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26921:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26922:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27180:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27181:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26922:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26923:1: ruleTransitionTerminal
+            // InternalRoom.g:27181:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27182:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72704,17 +73441,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__DocuAssignment_6"
-    // InternalRoom.g:26932:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27191:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__GuardedTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26936:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:26937:1: ( ruleDocumentation )
+            // InternalRoom.g:27195:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27196:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26937:1: ( ruleDocumentation )
-            // InternalRoom.g:26938:1: ruleDocumentation
+            // InternalRoom.g:27196:1: ( ruleDocumentation )
+            // InternalRoom.g:27197:1: ruleDocumentation
             {
              before(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72745,17 +73482,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__GuardAssignment_9"
-    // InternalRoom.g:26947:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27206:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ;
     public final void rule__GuardedTransition__GuardAssignment_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26951:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26952:1: ( ruleDetailCode )
+            // InternalRoom.g:27210:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27211:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26952:1: ( ruleDetailCode )
-            // InternalRoom.g:26953:1: ruleDetailCode
+            // InternalRoom.g:27211:1: ( ruleDetailCode )
+            // InternalRoom.g:27212:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -72786,17 +73523,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__ActionAssignment_10_1"
-    // InternalRoom.g:26962:1: rule__GuardedTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27221:1: rule__GuardedTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
     public final void rule__GuardedTransition__ActionAssignment_10_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26966:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:26967:1: ( ruleDetailCode )
+            // InternalRoom.g:27225:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27226:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26967:1: ( ruleDetailCode )
-            // InternalRoom.g:26968:1: ruleDetailCode
+            // InternalRoom.g:27226:1: ( ruleDetailCode )
+            // InternalRoom.g:27227:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72827,17 +73564,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__NameAssignment_1"
-    // InternalRoom.g:26977:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27236:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__CPBranchTransition__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26981:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26982:1: ( RULE_ID )
+            // InternalRoom.g:27240:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27241:1: ( RULE_ID )
             {
-            // InternalRoom.g:26982:1: ( RULE_ID )
-            // InternalRoom.g:26983:1: RULE_ID
+            // InternalRoom.g:27241:1: ( RULE_ID )
+            // InternalRoom.g:27242:1: RULE_ID
             {
              before(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72864,17 +73601,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__FromAssignment_3"
-    // InternalRoom.g:26992:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27251:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
     public final void rule__CPBranchTransition__FromAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:26996:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:26997:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27255:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27256:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26997:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26998:1: ruleTransitionTerminal
+            // InternalRoom.g:27256:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27257:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72905,17 +73642,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ToAssignment_5"
-    // InternalRoom.g:27007:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27266:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
     public final void rule__CPBranchTransition__ToAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27011:1: ( ( ruleTransitionTerminal ) )
-            // InternalRoom.g:27012:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27270:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27271:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:27012:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:27013:1: ruleTransitionTerminal
+            // InternalRoom.g:27271:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27272:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72946,17 +73683,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__DocuAssignment_6"
-    // InternalRoom.g:27022:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27281:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
     public final void rule__CPBranchTransition__DocuAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27026:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:27027:1: ( ruleDocumentation )
+            // InternalRoom.g:27285:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27286:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27027:1: ( ruleDocumentation )
-            // InternalRoom.g:27028:1: ruleDocumentation
+            // InternalRoom.g:27286:1: ( ruleDocumentation )
+            // InternalRoom.g:27287:1: ruleDocumentation
             {
              before(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72987,17 +73724,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ConditionAssignment_9"
-    // InternalRoom.g:27037:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27296:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ;
     public final void rule__CPBranchTransition__ConditionAssignment_9() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27041:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:27042:1: ( ruleDetailCode )
+            // InternalRoom.g:27300:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27301:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27042:1: ( ruleDetailCode )
-            // InternalRoom.g:27043:1: ruleDetailCode
+            // InternalRoom.g:27301:1: ( ruleDetailCode )
+            // InternalRoom.g:27302:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -73028,17 +73765,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ActionAssignment_10_1"
-    // InternalRoom.g:27052:1: rule__CPBranchTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27311:1: rule__CPBranchTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ;
     public final void rule__CPBranchTransition__ActionAssignment_10_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27056:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:27057:1: ( ruleDetailCode )
+            // InternalRoom.g:27315:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27316:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27057:1: ( ruleDetailCode )
-            // InternalRoom.g:27058:1: ruleDetailCode
+            // InternalRoom.g:27316:1: ( ruleDetailCode )
+            // InternalRoom.g:27317:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73069,21 +73806,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__TargetAssignment_1"
-    // InternalRoom.g:27067:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:27326:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ;
     public final void rule__RefinedTransition__TargetAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27071:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:27072:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27330:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:27331:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:27072:1: ( ( ruleFQN ) )
-            // InternalRoom.g:27073:1: ( ruleFQN )
+            // InternalRoom.g:27331:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27332:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); 
-            // InternalRoom.g:27074:1: ( ruleFQN )
-            // InternalRoom.g:27075:1: ruleFQN
+            // InternalRoom.g:27333:1: ( ruleFQN )
+            // InternalRoom.g:27334:1: ruleFQN
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -73118,17 +73855,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__DocuAssignment_2"
-    // InternalRoom.g:27086:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27345:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__RefinedTransition__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27090:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:27091:1: ( ruleDocumentation )
+            // InternalRoom.g:27349:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27350:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27091:1: ( ruleDocumentation )
-            // InternalRoom.g:27092:1: ruleDocumentation
+            // InternalRoom.g:27350:1: ( ruleDocumentation )
+            // InternalRoom.g:27351:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -73159,17 +73896,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__ActionAssignment_5"
-    // InternalRoom.g:27101:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27360:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ;
     public final void rule__RefinedTransition__ActionAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27105:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:27106:1: ( ruleDetailCode )
+            // InternalRoom.g:27364:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27365:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27106:1: ( ruleDetailCode )
-            // InternalRoom.g:27107:1: ruleDetailCode
+            // InternalRoom.g:27365:1: ( ruleDetailCode )
+            // InternalRoom.g:27366:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -73200,21 +73937,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateTerminal__StateAssignment"
-    // InternalRoom.g:27116:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27375:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ;
     public final void rule__StateTerminal__StateAssignment() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27120:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27121:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27379:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27380:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27121:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27122:1: ( RULE_ID )
+            // InternalRoom.g:27380:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27381:1: ( RULE_ID )
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); 
-            // InternalRoom.g:27123:1: ( RULE_ID )
-            // InternalRoom.g:27124:1: RULE_ID
+            // InternalRoom.g:27382:1: ( RULE_ID )
+            // InternalRoom.g:27383:1: RULE_ID
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73245,21 +73982,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__TrPointAssignment_1"
-    // InternalRoom.g:27135:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27394:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__TrPointTerminal__TrPointAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27139:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27140:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27398:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27399:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27140:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27141:1: ( RULE_ID )
+            // InternalRoom.g:27399:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27400:1: ( RULE_ID )
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); 
-            // InternalRoom.g:27142:1: ( RULE_ID )
-            // InternalRoom.g:27143:1: RULE_ID
+            // InternalRoom.g:27401:1: ( RULE_ID )
+            // InternalRoom.g:27402:1: RULE_ID
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73290,21 +74027,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__TrPointAssignment_0"
-    // InternalRoom.g:27154:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27413:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ;
     public final void rule__SubStateTrPointTerminal__TrPointAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27158:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27159:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27417:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27418:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27159:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27160:1: ( RULE_ID )
+            // InternalRoom.g:27418:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27419:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); 
-            // InternalRoom.g:27161:1: ( RULE_ID )
-            // InternalRoom.g:27162:1: RULE_ID
+            // InternalRoom.g:27420:1: ( RULE_ID )
+            // InternalRoom.g:27421:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73335,21 +74072,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__StateAssignment_2"
-    // InternalRoom.g:27173:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27432:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__SubStateTrPointTerminal__StateAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27177:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27178:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27436:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27437:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27178:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27179:1: ( RULE_ID )
+            // InternalRoom.g:27437:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27438:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); 
-            // InternalRoom.g:27180:1: ( RULE_ID )
-            // InternalRoom.g:27181:1: RULE_ID
+            // InternalRoom.g:27439:1: ( RULE_ID )
+            // InternalRoom.g:27440:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73380,21 +74117,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__CpAssignment_1"
-    // InternalRoom.g:27192:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27451:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ;
     public final void rule__ChoicepointTerminal__CpAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27196:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27197:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27455:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27456:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27197:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27198:1: ( RULE_ID )
+            // InternalRoom.g:27456:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27457:1: ( RULE_ID )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); 
-            // InternalRoom.g:27199:1: ( RULE_ID )
-            // InternalRoom.g:27200:1: RULE_ID
+            // InternalRoom.g:27458:1: ( RULE_ID )
+            // InternalRoom.g:27459:1: RULE_ID
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73425,17 +74162,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_1"
-    // InternalRoom.g:27211:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ;
+    // InternalRoom.g:27470:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ;
     public final void rule__Trigger__MsgFromIfPairsAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27215:1: ( ( ruleMessageFromIf ) )
-            // InternalRoom.g:27216:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27474:1: ( ( ruleMessageFromIf ) )
+            // InternalRoom.g:27475:1: ( ruleMessageFromIf )
             {
-            // InternalRoom.g:27216:1: ( ruleMessageFromIf )
-            // InternalRoom.g:27217:1: ruleMessageFromIf
+            // InternalRoom.g:27475:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27476:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73466,17 +74203,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_2_1"
-    // InternalRoom.g:27226:1: rule__Trigger__MsgFromIfPairsAssignment_2_1 : ( ruleMessageFromIf ) ;
+    // InternalRoom.g:27485:1: rule__Trigger__MsgFromIfPairsAssignment_2_1 : ( ruleMessageFromIf ) ;
     public final void rule__Trigger__MsgFromIfPairsAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27230:1: ( ( ruleMessageFromIf ) )
-            // InternalRoom.g:27231:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27489:1: ( ( ruleMessageFromIf ) )
+            // InternalRoom.g:27490:1: ( ruleMessageFromIf )
             {
-            // InternalRoom.g:27231:1: ( ruleMessageFromIf )
-            // InternalRoom.g:27232:1: ruleMessageFromIf
+            // InternalRoom.g:27490:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27491:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73507,17 +74244,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__GuardAssignment_3"
-    // InternalRoom.g:27241:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ;
+    // InternalRoom.g:27500:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ;
     public final void rule__Trigger__GuardAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27245:1: ( ( ruleGuard ) )
-            // InternalRoom.g:27246:1: ( ruleGuard )
+            // InternalRoom.g:27504:1: ( ( ruleGuard ) )
+            // InternalRoom.g:27505:1: ( ruleGuard )
             {
-            // InternalRoom.g:27246:1: ( ruleGuard )
-            // InternalRoom.g:27247:1: ruleGuard
+            // InternalRoom.g:27505:1: ( ruleGuard )
+            // InternalRoom.g:27506:1: ruleGuard
             {
              before(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -73548,21 +74285,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__MessageAssignment_0"
-    // InternalRoom.g:27256:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27515:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ;
     public final void rule__MessageFromIf__MessageAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27260:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27261:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27519:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27520:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27261:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27262:1: ( RULE_ID )
+            // InternalRoom.g:27520:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27521:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); 
-            // InternalRoom.g:27263:1: ( RULE_ID )
-            // InternalRoom.g:27264:1: RULE_ID
+            // InternalRoom.g:27522:1: ( RULE_ID )
+            // InternalRoom.g:27523:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73593,21 +74330,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__FromAssignment_2"
-    // InternalRoom.g:27275:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27534:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__MessageFromIf__FromAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27279:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27280:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27538:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27539:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27280:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27281:1: ( RULE_ID )
+            // InternalRoom.g:27539:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27540:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); 
-            // InternalRoom.g:27282:1: ( RULE_ID )
-            // InternalRoom.g:27283:1: RULE_ID
+            // InternalRoom.g:27541:1: ( RULE_ID )
+            // InternalRoom.g:27542:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73638,17 +74375,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__GuardAssignment_1"
-    // InternalRoom.g:27294:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27553:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ;
     public final void rule__Guard__GuardAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27298:1: ( ( ruleDetailCode ) )
-            // InternalRoom.g:27299:1: ( ruleDetailCode )
+            // InternalRoom.g:27557:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27558:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27299:1: ( ruleDetailCode )
-            // InternalRoom.g:27300:1: ruleDetailCode
+            // InternalRoom.g:27558:1: ( ruleDetailCode )
+            // InternalRoom.g:27559:1: ruleDetailCode
             {
              before(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73679,17 +74416,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__RulesAssignment_3"
-    // InternalRoom.g:27309:1: rule__ProtocolSemantics__RulesAssignment_3 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27568:1: rule__ProtocolSemantics__RulesAssignment_3 : ( ruleSemanticsRule ) ;
     public final void rule__ProtocolSemantics__RulesAssignment_3() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27313:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27314:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27572:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27573:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27314:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27315:1: ruleSemanticsRule
+            // InternalRoom.g:27573:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27574:1: ruleSemanticsRule
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -73720,21 +74457,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__MsgAssignment_2"
-    // InternalRoom.g:27324:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27583:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__InSemanticsRule__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27328:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27329:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27587:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27588:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27329:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27330:1: ( RULE_ID )
+            // InternalRoom.g:27588:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27589:1: ( RULE_ID )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalRoom.g:27331:1: ( RULE_ID )
-            // InternalRoom.g:27332:1: RULE_ID
+            // InternalRoom.g:27590:1: ( RULE_ID )
+            // InternalRoom.g:27591:1: RULE_ID
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73765,17 +74502,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_0"
-    // InternalRoom.g:27343:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27602:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27347:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27348:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27606:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27607:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27348:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27349:1: ruleSemanticsRule
+            // InternalRoom.g:27607:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27608:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -73806,17 +74543,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1"
-    // InternalRoom.g:27358:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27617:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27362:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27363:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27621:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27622:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27363:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27364:1: ruleSemanticsRule
+            // InternalRoom.g:27622:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27623:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73847,17 +74584,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1"
-    // InternalRoom.g:27373:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27632:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
     public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27377:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27378:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27636:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27637:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27378:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27379:1: ruleSemanticsRule
+            // InternalRoom.g:27637:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27638:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73888,21 +74625,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__MsgAssignment_2"
-    // InternalRoom.g:27388:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27647:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
     public final void rule__OutSemanticsRule__MsgAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27392:1: ( ( ( RULE_ID ) ) )
-            // InternalRoom.g:27393:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27651:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27652:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27393:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27394:1: ( RULE_ID )
+            // InternalRoom.g:27652:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27653:1: ( RULE_ID )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalRoom.g:27395:1: ( RULE_ID )
-            // InternalRoom.g:27396:1: RULE_ID
+            // InternalRoom.g:27654:1: ( RULE_ID )
+            // InternalRoom.g:27655:1: RULE_ID
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73933,17 +74670,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_0"
-    // InternalRoom.g:27407:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27666:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27411:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27412:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27670:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27671:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27412:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27413:1: ruleSemanticsRule
+            // InternalRoom.g:27671:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27672:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -73974,17 +74711,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1"
-    // InternalRoom.g:27422:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27681:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27426:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27427:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27685:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27686:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27427:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27428:1: ruleSemanticsRule
+            // InternalRoom.g:27686:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27687:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74015,17 +74752,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1"
-    // InternalRoom.g:27437:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27696:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ;
     public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27441:1: ( ( ruleSemanticsRule ) )
-            // InternalRoom.g:27442:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27700:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27701:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27442:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27443:1: ruleSemanticsRule
+            // InternalRoom.g:27701:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27702:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74056,21 +74793,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__TypeAssignment_1"
-    // InternalRoom.g:27452:1: rule__Annotation__TypeAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:27711:1: rule__Annotation__TypeAssignment_1 : ( ( ruleFQN ) ) ;
     public final void rule__Annotation__TypeAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27456:1: ( ( ( ruleFQN ) ) )
-            // InternalRoom.g:27457:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27715:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:27716:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:27457:1: ( ( ruleFQN ) )
-            // InternalRoom.g:27458:1: ( ruleFQN )
+            // InternalRoom.g:27716:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27717:1: ( ruleFQN )
             {
              before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeCrossReference_1_0()); 
-            // InternalRoom.g:27459:1: ( ruleFQN )
-            // InternalRoom.g:27460:1: ruleFQN
+            // InternalRoom.g:27718:1: ( ruleFQN )
+            // InternalRoom.g:27719:1: ruleFQN
             {
              before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -74105,17 +74842,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__AttributesAssignment_2_1"
-    // InternalRoom.g:27471:1: rule__Annotation__AttributesAssignment_2_1 : ( ruleKeyValue ) ;
+    // InternalRoom.g:27730:1: rule__Annotation__AttributesAssignment_2_1 : ( ruleKeyValue ) ;
     public final void rule__Annotation__AttributesAssignment_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27475:1: ( ( ruleKeyValue ) )
-            // InternalRoom.g:27476:1: ( ruleKeyValue )
+            // InternalRoom.g:27734:1: ( ( ruleKeyValue ) )
+            // InternalRoom.g:27735:1: ( ruleKeyValue )
             {
-            // InternalRoom.g:27476:1: ( ruleKeyValue )
-            // InternalRoom.g:27477:1: ruleKeyValue
+            // InternalRoom.g:27735:1: ( ruleKeyValue )
+            // InternalRoom.g:27736:1: ruleKeyValue
             {
              before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74146,17 +74883,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__AttributesAssignment_2_2_1"
-    // InternalRoom.g:27486:1: rule__Annotation__AttributesAssignment_2_2_1 : ( ruleKeyValue ) ;
+    // InternalRoom.g:27745:1: rule__Annotation__AttributesAssignment_2_2_1 : ( ruleKeyValue ) ;
     public final void rule__Annotation__AttributesAssignment_2_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27490:1: ( ( ruleKeyValue ) )
-            // InternalRoom.g:27491:1: ( ruleKeyValue )
+            // InternalRoom.g:27749:1: ( ( ruleKeyValue ) )
+            // InternalRoom.g:27750:1: ( ruleKeyValue )
             {
-            // InternalRoom.g:27491:1: ( ruleKeyValue )
-            // InternalRoom.g:27492:1: ruleKeyValue
+            // InternalRoom.g:27750:1: ( ruleKeyValue )
+            // InternalRoom.g:27751:1: ruleKeyValue
             {
              before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74187,17 +74924,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__KeyAssignment_0"
-    // InternalRoom.g:27501:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:27760:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ;
     public final void rule__KeyValue__KeyAssignment_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27505:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27506:1: ( RULE_ID )
+            // InternalRoom.g:27764:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27765:1: ( RULE_ID )
             {
-            // InternalRoom.g:27506:1: ( RULE_ID )
-            // InternalRoom.g:27507:1: RULE_ID
+            // InternalRoom.g:27765:1: ( RULE_ID )
+            // InternalRoom.g:27766:1: RULE_ID
             {
              before(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74224,17 +74961,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__ValueAssignment_2"
-    // InternalRoom.g:27516:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ;
+    // InternalRoom.g:27775:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ;
     public final void rule__KeyValue__ValueAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27520:1: ( ( ruleLiteral ) )
-            // InternalRoom.g:27521:1: ( ruleLiteral )
+            // InternalRoom.g:27779:1: ( ( ruleLiteral ) )
+            // InternalRoom.g:27780:1: ( ruleLiteral )
             {
-            // InternalRoom.g:27521:1: ( ruleLiteral )
-            // InternalRoom.g:27522:1: ruleLiteral
+            // InternalRoom.g:27780:1: ( ruleLiteral )
+            // InternalRoom.g:27781:1: ruleLiteral
             {
              before(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -74265,17 +75002,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__NameAssignment_1"
-    // InternalRoom.g:27531:1: rule__AnnotationType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27790:1: rule__AnnotationType__NameAssignment_1 : ( RULE_ID ) ;
     public final void rule__AnnotationType__NameAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27535:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27536:1: ( RULE_ID )
+            // InternalRoom.g:27794:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27795:1: ( RULE_ID )
             {
-            // InternalRoom.g:27536:1: ( RULE_ID )
-            // InternalRoom.g:27537:1: RULE_ID
+            // InternalRoom.g:27795:1: ( RULE_ID )
+            // InternalRoom.g:27796:1: RULE_ID
             {
              before(grammarAccess.getAnnotationTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74302,17 +75039,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__DocuAssignment_2"
-    // InternalRoom.g:27546:1: rule__AnnotationType__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27805:1: rule__AnnotationType__DocuAssignment_2 : ( ruleDocumentation ) ;
     public final void rule__AnnotationType__DocuAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27550:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:27551:1: ( ruleDocumentation )
+            // InternalRoom.g:27809:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27810:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27551:1: ( ruleDocumentation )
-            // InternalRoom.g:27552:1: ruleDocumentation
+            // InternalRoom.g:27810:1: ( ruleDocumentation )
+            // InternalRoom.g:27811:1: ruleDocumentation
             {
              before(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -74343,17 +75080,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__TargetsAssignment_6_0"
-    // InternalRoom.g:27561:1: rule__AnnotationType__TargetsAssignment_6_0 : ( ruleAnnotationTargetType ) ;
+    // InternalRoom.g:27820:1: rule__AnnotationType__TargetsAssignment_6_0 : ( ruleAnnotationTargetType ) ;
     public final void rule__AnnotationType__TargetsAssignment_6_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27565:1: ( ( ruleAnnotationTargetType ) )
-            // InternalRoom.g:27566:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27824:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27825:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27566:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27567:1: ruleAnnotationTargetType
+            // InternalRoom.g:27825:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27826:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); 
             pushFollow(FOLLOW_2);
@@ -74384,17 +75121,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__TargetsAssignment_6_1_1"
-    // InternalRoom.g:27576:1: rule__AnnotationType__TargetsAssignment_6_1_1 : ( ruleAnnotationTargetType ) ;
+    // InternalRoom.g:27835:1: rule__AnnotationType__TargetsAssignment_6_1_1 : ( ruleAnnotationTargetType ) ;
     public final void rule__AnnotationType__TargetsAssignment_6_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27580:1: ( ( ruleAnnotationTargetType ) )
-            // InternalRoom.g:27581:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27839:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27840:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27581:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27582:1: ruleAnnotationTargetType
+            // InternalRoom.g:27840:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27841:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74425,17 +75162,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__TargetsAssignment_6_1_2_1"
-    // InternalRoom.g:27591:1: rule__AnnotationType__TargetsAssignment_6_1_2_1 : ( ruleAnnotationTargetType ) ;
+    // InternalRoom.g:27850:1: rule__AnnotationType__TargetsAssignment_6_1_2_1 : ( ruleAnnotationTargetType ) ;
     public final void rule__AnnotationType__TargetsAssignment_6_1_2_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27595:1: ( ( ruleAnnotationTargetType ) )
-            // InternalRoom.g:27596:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27854:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27855:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27596:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27597:1: ruleAnnotationTargetType
+            // InternalRoom.g:27855:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27856:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74466,17 +75203,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__AttributesAssignment_7"
-    // InternalRoom.g:27606:1: rule__AnnotationType__AttributesAssignment_7 : ( ruleAnnotationAttribute ) ;
+    // InternalRoom.g:27865:1: rule__AnnotationType__AttributesAssignment_7 : ( ruleAnnotationAttribute ) ;
     public final void rule__AnnotationType__AttributesAssignment_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27610:1: ( ( ruleAnnotationAttribute ) )
-            // InternalRoom.g:27611:1: ( ruleAnnotationAttribute )
+            // InternalRoom.g:27869:1: ( ( ruleAnnotationAttribute ) )
+            // InternalRoom.g:27870:1: ( ruleAnnotationAttribute )
             {
-            // InternalRoom.g:27611:1: ( ruleAnnotationAttribute )
-            // InternalRoom.g:27612:1: ruleAnnotationAttribute
+            // InternalRoom.g:27870:1: ( ruleAnnotationAttribute )
+            // InternalRoom.g:27871:1: ruleAnnotationAttribute
             {
              before(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -74507,21 +75244,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__OptionalAssignment_0_0"
-    // InternalRoom.g:27621:1: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
+    // InternalRoom.g:27880:1: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
     public final void rule__SimpleAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27625:1: ( ( ( 'optional' ) ) )
-            // InternalRoom.g:27626:1: ( ( 'optional' ) )
+            // InternalRoom.g:27884:1: ( ( ( 'optional' ) ) )
+            // InternalRoom.g:27885:1: ( ( 'optional' ) )
             {
-            // InternalRoom.g:27626:1: ( ( 'optional' ) )
-            // InternalRoom.g:27627:1: ( 'optional' )
+            // InternalRoom.g:27885:1: ( ( 'optional' ) )
+            // InternalRoom.g:27886:1: ( 'optional' )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalRoom.g:27628:1: ( 'optional' )
-            // InternalRoom.g:27629:1: 'optional'
+            // InternalRoom.g:27887:1: ( 'optional' )
+            // InternalRoom.g:27888:1: 'optional'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,37,FOLLOW_2); 
@@ -74552,17 +75289,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__NameAssignment_2"
-    // InternalRoom.g:27644:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:27903:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__SimpleAnnotationAttribute__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27648:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27649:1: ( RULE_ID )
+            // InternalRoom.g:27907:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27908:1: ( RULE_ID )
             {
-            // InternalRoom.g:27649:1: ( RULE_ID )
-            // InternalRoom.g:27650:1: RULE_ID
+            // InternalRoom.g:27908:1: ( RULE_ID )
+            // InternalRoom.g:27909:1: RULE_ID
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74589,17 +75326,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__TypeAssignment_4"
-    // InternalRoom.g:27659:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ;
+    // InternalRoom.g:27918:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ;
     public final void rule__SimpleAnnotationAttribute__TypeAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27663:1: ( ( ruleLiteralType ) )
-            // InternalRoom.g:27664:1: ( ruleLiteralType )
+            // InternalRoom.g:27922:1: ( ( ruleLiteralType ) )
+            // InternalRoom.g:27923:1: ( ruleLiteralType )
             {
-            // InternalRoom.g:27664:1: ( ruleLiteralType )
-            // InternalRoom.g:27665:1: ruleLiteralType
+            // InternalRoom.g:27923:1: ( ruleLiteralType )
+            // InternalRoom.g:27924:1: ruleLiteralType
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -74630,21 +75367,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__OptionalAssignment_0_0"
-    // InternalRoom.g:27674:1: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
+    // InternalRoom.g:27933:1: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ;
     public final void rule__EnumAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27678:1: ( ( ( 'optional' ) ) )
-            // InternalRoom.g:27679:1: ( ( 'optional' ) )
+            // InternalRoom.g:27937:1: ( ( ( 'optional' ) ) )
+            // InternalRoom.g:27938:1: ( ( 'optional' ) )
             {
-            // InternalRoom.g:27679:1: ( ( 'optional' ) )
-            // InternalRoom.g:27680:1: ( 'optional' )
+            // InternalRoom.g:27938:1: ( ( 'optional' ) )
+            // InternalRoom.g:27939:1: ( 'optional' )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalRoom.g:27681:1: ( 'optional' )
-            // InternalRoom.g:27682:1: 'optional'
+            // InternalRoom.g:27940:1: ( 'optional' )
+            // InternalRoom.g:27941:1: 'optional'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,37,FOLLOW_2); 
@@ -74675,17 +75412,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__NameAssignment_2"
-    // InternalRoom.g:27697:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:27956:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
     public final void rule__EnumAnnotationAttribute__NameAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27701:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27702:1: ( RULE_ID )
+            // InternalRoom.g:27960:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27961:1: ( RULE_ID )
             {
-            // InternalRoom.g:27702:1: ( RULE_ID )
-            // InternalRoom.g:27703:1: RULE_ID
+            // InternalRoom.g:27961:1: ( RULE_ID )
+            // InternalRoom.g:27962:1: RULE_ID
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74712,17 +75449,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_5"
-    // InternalRoom.g:27712:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ;
+    // InternalRoom.g:27971:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ;
     public final void rule__EnumAnnotationAttribute__ValuesAssignment_5() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27716:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:27717:1: ( RULE_STRING )
+            // InternalRoom.g:27975:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27976:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27717:1: ( RULE_STRING )
-            // InternalRoom.g:27718:1: RULE_STRING
+            // InternalRoom.g:27976:1: ( RULE_STRING )
+            // InternalRoom.g:27977:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74749,17 +75486,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_6_1"
-    // InternalRoom.g:27727:1: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:27986:1: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 : ( RULE_STRING ) ;
     public final void rule__EnumAnnotationAttribute__ValuesAssignment_6_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27731:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:27732:1: ( RULE_STRING )
+            // InternalRoom.g:27990:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27991:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27732:1: ( RULE_STRING )
-            // InternalRoom.g:27733:1: RULE_STRING
+            // InternalRoom.g:27991:1: ( RULE_STRING )
+            // InternalRoom.g:27992:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74786,17 +75523,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__ImportedNamespaceAssignment_1_0_0"
-    // InternalRoom.g:27742:1: rule__Import__ImportedNamespaceAssignment_1_0_0 : ( ruleImportedFQN ) ;
+    // InternalRoom.g:28001:1: rule__Import__ImportedNamespaceAssignment_1_0_0 : ( ruleImportedFQN ) ;
     public final void rule__Import__ImportedNamespaceAssignment_1_0_0() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27746:1: ( ( ruleImportedFQN ) )
-            // InternalRoom.g:27747:1: ( ruleImportedFQN )
+            // InternalRoom.g:28005:1: ( ( ruleImportedFQN ) )
+            // InternalRoom.g:28006:1: ( ruleImportedFQN )
             {
-            // InternalRoom.g:27747:1: ( ruleImportedFQN )
-            // InternalRoom.g:27748:1: ruleImportedFQN
+            // InternalRoom.g:28006:1: ( ruleImportedFQN )
+            // InternalRoom.g:28007:1: ruleImportedFQN
             {
              before(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); 
             pushFollow(FOLLOW_2);
@@ -74827,17 +75564,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__ImportURIAssignment_2"
-    // InternalRoom.g:27757:1: rule__Import__ImportURIAssignment_2 : ( RULE_STRING ) ;
+    // InternalRoom.g:28016:1: rule__Import__ImportURIAssignment_2 : ( RULE_STRING ) ;
     public final void rule__Import__ImportURIAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27761:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:27762:1: ( RULE_STRING )
+            // InternalRoom.g:28020:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:28021:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27762:1: ( RULE_STRING )
-            // InternalRoom.g:27763:1: RULE_STRING
+            // InternalRoom.g:28021:1: ( RULE_STRING )
+            // InternalRoom.g:28022:1: RULE_STRING
             {
              before(grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_2_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74864,17 +75601,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__LinesAssignment_2"
-    // InternalRoom.g:27772:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ;
+    // InternalRoom.g:28031:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ;
     public final void rule__Documentation__LinesAssignment_2() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27776:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:27777:1: ( RULE_STRING )
+            // InternalRoom.g:28035:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:28036:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27777:1: ( RULE_STRING )
-            // InternalRoom.g:27778:1: RULE_STRING
+            // InternalRoom.g:28036:1: ( RULE_STRING )
+            // InternalRoom.g:28037:1: RULE_STRING
             {
              before(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74901,21 +75638,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__IsTrueAssignment_1_1"
-    // InternalRoom.g:27789:1: rule__BooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
+    // InternalRoom.g:28048:1: rule__BooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
     public final void rule__BooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27793:1: ( ( ( 'true' ) ) )
-            // InternalRoom.g:27794:1: ( ( 'true' ) )
+            // InternalRoom.g:28052:1: ( ( ( 'true' ) ) )
+            // InternalRoom.g:28053:1: ( ( 'true' ) )
             {
-            // InternalRoom.g:27794:1: ( ( 'true' ) )
-            // InternalRoom.g:27795:1: ( 'true' )
+            // InternalRoom.g:28053:1: ( ( 'true' ) )
+            // InternalRoom.g:28054:1: ( 'true' )
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
-            // InternalRoom.g:27796:1: ( 'true' )
-            // InternalRoom.g:27797:1: 'true'
+            // InternalRoom.g:28055:1: ( 'true' )
+            // InternalRoom.g:28056:1: 'true'
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
             match(input,132,FOLLOW_2); 
@@ -74946,17 +75683,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__ValueAssignment_1"
-    // InternalRoom.g:27812:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ;
+    // InternalRoom.g:28071:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ;
     public final void rule__RealLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27816:1: ( ( ruleReal ) )
-            // InternalRoom.g:27817:1: ( ruleReal )
+            // InternalRoom.g:28075:1: ( ( ruleReal ) )
+            // InternalRoom.g:28076:1: ( ruleReal )
             {
-            // InternalRoom.g:27817:1: ( ruleReal )
-            // InternalRoom.g:27818:1: ruleReal
+            // InternalRoom.g:28076:1: ( ruleReal )
+            // InternalRoom.g:28077:1: ruleReal
             {
              before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74987,17 +75724,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__ValueAssignment_1"
-    // InternalRoom.g:27827:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ;
+    // InternalRoom.g:28086:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ;
     public final void rule__IntLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27831:1: ( ( ruleInteger ) )
-            // InternalRoom.g:27832:1: ( ruleInteger )
+            // InternalRoom.g:28090:1: ( ( ruleInteger ) )
+            // InternalRoom.g:28091:1: ( ruleInteger )
             {
-            // InternalRoom.g:27832:1: ( ruleInteger )
-            // InternalRoom.g:27833:1: ruleInteger
+            // InternalRoom.g:28091:1: ( ruleInteger )
+            // InternalRoom.g:28092:1: ruleInteger
             {
              before(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -75028,17 +75765,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__ValueAssignment_1"
-    // InternalRoom.g:27842:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:28101:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
     public final void rule__StringLiteral__ValueAssignment_1() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:27846:1: ( ( RULE_STRING ) )
-            // InternalRoom.g:27847:1: ( RULE_STRING )
+            // InternalRoom.g:28105:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:28106:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27847:1: ( RULE_STRING )
-            // InternalRoom.g:27848:1: RULE_STRING
+            // InternalRoom.g:28106:1: ( RULE_STRING )
+            // InternalRoom.g:28107:1: RULE_STRING
             {
              before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -75067,8 +75804,8 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     protected DFA1 dfa1 = new DFA1(this);
-    protected DFA30 dfa30 = new DFA30(this);
     protected DFA31 dfa31 = new DFA31(this);
+    protected DFA32 dfa32 = new DFA32(this);
     static final String dfa_1s = "\15\uffff";
     static final String dfa_2s = "\1\21\4\uffff\3\22\5\uffff";
     static final String dfa_3s = "\1\u0082\4\uffff\3\u0082\5\uffff";
@@ -75111,13 +75848,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_6;
         }
         public String getDescription() {
-            return "3056:1: rule__RoomModel__Alternatives_5 : ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) );";
+            return "3110:1: rule__RoomModel__Alternatives_5 : ( ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) ) | ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) ) | ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) ) | ( ( rule__RoomModel__DataClassesAssignment_5_3 ) ) | ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) ) | ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) ) | ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) ) | ( ( rule__RoomModel__SystemsAssignment_5_7 ) ) | ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) ) );";
         }
     }
     static final String dfa_7s = "\32\uffff";
-    static final String dfa_8s = "\13\uffff\1\22\7\uffff\3\22\1\uffff\1\22\2\uffff";
-    static final String dfa_9s = "\1\151\1\6\1\56\1\6\1\60\4\6\2\60\1\54\2\6\1\60\1\6\1\7\1\55\1\uffff\3\54\1\7\1\54\2\uffff";
-    static final String dfa_10s = "\1\151\2\56\1\162\1\65\2\6\1\162\1\6\2\60\1\u0083\2\6\1\60\1\6\1\77\1\157\1\uffff\3\u0083\1\77\1\u0083\2\uffff";
+    static final String dfa_8s = "\14\uffff\1\22\6\uffff\3\22\1\uffff\1\22\2\uffff";
+    static final String dfa_9s = "\1\151\1\6\1\56\1\6\1\60\4\6\3\60\1\54\3\6\1\7\1\55\1\uffff\3\54\1\7\1\54\2\uffff";
+    static final String dfa_10s = "\1\151\2\56\1\162\1\65\3\6\1\162\3\60\1\u0083\3\6\1\77\1\157\1\uffff\3\u0083\1\77\1\u0083\2\uffff";
     static final String dfa_11s = "\22\uffff\1\2\5\uffff\1\1\1\3";
     static final String dfa_12s = "\32\uffff}>";
     static final String[] dfa_13s = {
@@ -75125,17 +75862,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             "\1\2\47\uffff\1\3",
             "\1\3",
             "\1\4\152\uffff\1\5\1\6",
-            "\1\7\4\uffff\1\10",
+            "\1\10\4\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\152\uffff\1\14\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
+            "\1\13",
+            "\1\14\152\uffff\1\15\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
             "\1\21\1\22\7\uffff\1\17\10\uffff\1\20\40\uffff\1\22\4\uffff\6\22\6\uffff\1\22\22\uffff\1\22",
             "\1\23",
             "\1\24",
-            "\1\7",
             "\1\25",
             "\1\26\67\uffff\1\27",
             "\1\22\75\uffff\1\22\1\30\1\uffff\1\30\1\31",
@@ -75157,11 +75894,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
     static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
 
-    class DFA30 extends DFA {
+    class DFA31 extends DFA {
 
-        public DFA30(BaseRecognizer recognizer) {
+        public DFA31(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 30;
+            this.decisionNumber = 31;
             this.eot = dfa_7;
             this.eof = dfa_8;
             this.min = dfa_9;
@@ -75171,40 +75908,40 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_13;
         }
         public String getDescription() {
-            return "3955:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );";
+            return "4030:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );";
         }
     }
     static final String dfa_14s = "\31\uffff";
-    static final String dfa_15s = "\1\151\1\6\1\56\1\6\1\60\4\6\2\60\1\54\2\6\1\60\1\6\1\7\1\154\3\54\1\7\1\54\2\uffff";
-    static final String dfa_16s = "\1\151\2\56\1\162\1\65\2\6\1\162\1\6\2\60\1\76\2\6\1\60\1\6\1\77\1\156\3\76\1\77\1\54\2\uffff";
-    static final String dfa_17s = "\27\uffff\1\1\1\2";
+    static final String dfa_15s = "\1\151\1\6\1\56\1\6\1\60\4\6\3\60\1\54\2\6\1\7\1\154\1\6\2\54\1\7\1\54\2\uffff\1\54";
+    static final String dfa_16s = "\1\151\2\56\1\162\1\65\3\6\1\162\3\60\1\76\2\6\1\77\1\156\1\6\2\76\1\77\1\54\2\uffff\1\76";
+    static final String dfa_17s = "\26\uffff\1\1\1\2\1\uffff";
     static final String dfa_18s = "\31\uffff}>";
     static final String[] dfa_19s = {
             "\1\1",
             "\1\2\47\uffff\1\3",
             "\1\3",
             "\1\4\152\uffff\1\5\1\6",
-            "\1\7\4\uffff\1\10",
+            "\1\10\4\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\152\uffff\1\14\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
-            "\1\21\10\uffff\1\17\10\uffff\1\20",
+            "\1\13",
+            "\1\14\152\uffff\1\15\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
+            "\1\20\10\uffff\1\21\10\uffff\1\17",
             "\1\22",
             "\1\23",
-            "\1\7",
-            "\1\24",
-            "\1\25\67\uffff\1\26",
-            "\1\27\1\uffff\1\30",
-            "\1\21\21\uffff\1\20",
-            "\1\21\21\uffff\1\20",
-            "\1\21\21\uffff\1\20",
-            "\1\25\67\uffff\1\26",
-            "\1\21",
+            "\1\24\67\uffff\1\25",
+            "\1\26\1\uffff\1\27",
+            "\1\30",
+            "\1\20\21\uffff\1\17",
+            "\1\20\21\uffff\1\17",
+            "\1\24\67\uffff\1\25",
+            "\1\20",
             "",
-            ""
+            "",
+            "\1\20\21\uffff\1\17"
     };
 
     static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s);
@@ -75214,11 +75951,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
     static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s);
 
-    class DFA31 extends DFA {
+    class DFA32 extends DFA {
 
-        public DFA31(BaseRecognizer recognizer) {
+        public DFA32(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 31;
+            this.decisionNumber = 32;
             this.eot = dfa_14;
             this.eof = dfa_14;
             this.min = dfa_15;
@@ -75228,7 +75965,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_19;
         }
         public String getDescription() {
-            return "3983:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
+            return "4058:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
         }
     }
  
@@ -75279,7 +76016,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000200000000000L,0x0200000000000080L});
     public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
     public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000000L,0x0000000000000002L});
-    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x4000000000000000L,0x0200000000000000L});
+    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x4004000000000000L,0x0200000000000000L});
     public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x200020000000C000L,0x0000000000000301L,0x0000000000000001L});
     public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x200000000000C002L,0x0000000000000201L,0x0000000000000001L});
     public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
@@ -75293,67 +76030,68 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x000020000000C000L,0x0200000040000001L,0x0000000000000001L});
     public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x000000000000C002L,0x0000000000000001L,0x0000000000000001L});
     public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000001000000L,0x0000000000008040L});
-    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000001000000L});
-    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0020000000000000L});
-    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000200000000000L,0x0200000002220000L});
-    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000002L,0x0000000002220000L});
-    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x1C00203001000000L,0x02000000222C8040L});
-    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000003001000002L,0x00000000222C8040L});
-    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000200000000000L,0x0000000000080000L});
-    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
-    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
-    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000002L,0x0000000000100000L});
-    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
-    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
-    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
-    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L});
-    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});
-    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000003000000000L,0x0000000020000000L});
-    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000010010L});
-    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000200000000000L,0x000103F080000000L,0x0000000000000008L});
-    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000000002L,0x000103F080000000L,0x0000000000000008L});
-    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
-    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000200000000000L,0x0000000F00000000L});
-    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000100L});
-    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000200000000080L});
-    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000082L});
-    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L,0x0000000000000008L});
-    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000400000000040L});
-    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
-    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000040L,0x0006000000000000L});
-    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000200000000000L,0x0000080000000000L});
-    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L});
-    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L});
-    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000200000000000L,0x0000200000000000L});
-    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000002L,0x0000200000000000L});
-    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
-    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
-    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L});
-    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000200000000000L});
-    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000000L,0x0030400000000000L});
-    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000002L,0x0020000000000000L});
-    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000000L,0x0040000000000000L});
-    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000200000000000L,0x0180000000000000L});
-    public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000002L,0x0180000000000000L});
-    public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0004000000000000L,0x0180000000000000L});
-    public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000000000000000L,0x0180000000000000L});
-    public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0048000000000000L});
-    public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x00000000700000B0L,0x0000000000000000L,0x0000000000000010L});
-    public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
-    public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000100003FE0000L});
-    public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000202004000000L});
-    public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000002004000002L});
-    public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000003FE0000L});
-    public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0040200000000000L});
-    public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
-    public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0000000008000040L});
-    public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L});
-    public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000000000L,0x8000000000000000L});
-    public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x8000000000000080L});
-    public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000010L});
-    public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000060000010L});
-    public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000180000000L});
-    public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
-    public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000004E00000002L,0x0000000000000000L,0x0000000000000004L});
+    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x4000000000000000L,0x0200000000000000L});
+    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000001000000L});
+    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0020000000000000L});
+    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000200000000000L,0x0200000002220000L});
+    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000002L,0x0000000002220000L});
+    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x1C00203001000000L,0x02000000222C8040L});
+    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000003001000002L,0x00000000222C8040L});
+    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000200000000000L,0x0000000000080000L});
+    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
+    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
+    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000002L,0x0000000000100000L});
+    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
+    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
+    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
+    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L});
+    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});
+    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000003000000000L,0x0000000020000000L});
+    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000010010L});
+    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000200000000000L,0x000103F080000000L,0x0000000000000008L});
+    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000000002L,0x000103F080000000L,0x0000000000000008L});
+    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
+    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000200000000000L,0x0000000F00000000L});
+    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000100L});
+    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000200000000080L});
+    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000082L});
+    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L,0x0000000000000008L});
+    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000400000000040L});
+    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
+    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000040L,0x0006000000000000L});
+    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000200000000000L,0x0000080000000000L});
+    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L});
+    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L});
+    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000200000000000L,0x0000200000000000L});
+    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000002L,0x0000200000000000L});
+    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
+    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
+    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L});
+    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000200000000000L});
+    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0030400000000000L});
+    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000002L,0x0020000000000000L});
+    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000000000000000L,0x0040000000000000L});
+    public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000200000000000L,0x0180000000000000L});
+    public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0000000000000002L,0x0180000000000000L});
+    public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0004000000000000L,0x0180000000000000L});
+    public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000000L,0x0180000000000000L});
+    public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0048000000000000L});
+    public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x00000000700000B0L,0x0000000000000000L,0x0000000000000010L});
+    public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
+    public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000100003FE0000L});
+    public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000202004000000L});
+    public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000002004000002L});
+    public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000003FE0000L});
+    public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0040200000000000L});
+    public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
+    public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000008000040L});
+    public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L});
+    public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000000000L,0x8000000000000000L});
+    public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x8000000000000080L});
+    public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000010L});
+    public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000060000010L});
+    public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000180000000L});
+    public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
+    public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x0000004E00000002L,0x0000000000000000L,0x0000000000000004L});
 
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/contentassist/RoomProposalProvider.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/contentassist/RoomProposalProvider.java
index f6f141e49..30b9f23df 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/contentassist/RoomProposalProvider.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/contentassist/RoomProposalProvider.java
@@ -35,7 +35,6 @@ import org.eclipse.etrice.core.room.RoomPackage;
 import org.eclipse.etrice.core.room.StandardOperation;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 import org.eclipse.etrice.core.ui.util.UIExpressionUtil;
-import org.eclipse.etrice.expressions.detailcode.DefaultDetailExpressionProvider;
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider;
 import org.eclipse.etrice.expressions.ui.contentassist.RoomExpressionProposalProvider;
 import org.eclipse.jface.text.contentassist.ICompletionProposal;
@@ -227,16 +226,21 @@ public class RoomProposalProvider extends AbstractRoomProposalProvider {
 	
 	@Inject
 	RoomExpressionProposalProvider expressionProposalAdapter;
+	//@Inject private DCUtil util;
 	
 	@Override
 	public void complete_CC_STRING(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
-		String text = context.getCurrentNode().getText();
-		int localOffset = context.getOffset() - context.getCurrentNode().getOffset();
-		int globalOffset = context.getOffset();
 		if (context.getCurrentNode().getSemanticElement() instanceof DetailCode) {
-			IDetailExpressionProvider exprPovider = UIExpressionUtil.selectExpressionProvider(model);
+			String text = context.getCurrentNode().getText();
+			int localOffset = context.getOffset() - context.getCurrentNode().getOffset();
+			int globalOffset = context.getOffset();
+			DetailCode detailCode = (DetailCode) context.getCurrentNode().getSemanticElement();
+			IDetailExpressionProvider exprPovider = UIExpressionUtil.getExpressionProvider(detailCode);
 			for(ICompletionProposal proposal : expressionProposalAdapter.createProposals(exprPovider, text, localOffset, globalOffset))
 				acceptor.accept(proposal);
+			
+			// new implementation TODO
+			//util.getProposals(context.getCurrentNode(), context.getOffset());
 		}
 
 		super.complete_CC_STRING(model, ruleCall, context, acceptor);
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateActionCodes.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateActionCodes.xtend
new file mode 100644
index 000000000..373f36e58
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateActionCodes.xtend
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.ui.handlers
+
+import com.google.inject.Inject
+import org.eclipse.core.commands.AbstractHandler
+import org.eclipse.core.commands.ExecutionEvent
+import org.eclipse.core.commands.ExecutionException
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.jface.dialogs.MessageDialog
+import org.eclipse.swt.widgets.Display
+import org.eclipse.xtext.formatting.IWhitespaceInformationProvider
+import org.eclipse.xtext.resource.XtextResource
+import org.eclipse.xtext.ui.editor.utils.EditorUtils
+import org.eclipse.xtext.util.concurrent.IUnitOfWork
+
+class MigrateActionCodes extends AbstractHandler {
+
+	@Inject
+	IWhitespaceInformationProvider whitespaceProvider;
+	
+	static class MigrateContext {
+		var String lineSep
+		var int actionCodesChanged = 0
+	}
+	
+	override execute(ExecutionEvent event) throws ExecutionException {
+		
+		val proceed = MessageDialog.openQuestion(
+			Display.current.activeShell,
+			"Migrate action codes to smart strings",
+			"This migration will convert all action codes to smart strings.\n\n"
+			+ "Proceed?"
+		)
+		if (proceed) {
+			val editor = EditorUtils.getActiveXtextEditor(event)
+			if (editor!==null) {
+					val ctx = editor.getDocument().modify(new IUnitOfWork<MigrateContext, XtextResource>() {
+					
+					override exec(XtextResource state) throws Exception {
+						val ctx = new MigrateContext => [
+							lineSep = whitespaceProvider.getLineSeparatorInformation(state.URI).lineSeparator
+						]
+						for (model : state.getContents()) {
+							migrateModel(model, ctx)				
+						}
+						return ctx
+					}
+					
+						
+					});
+				MessageDialog.openInformation(
+					Display.current.activeShell,
+					"Migrate action codes to smart strings",
+					"Changed " + ctx.actionCodesChanged + " action codes to smart strings.\n\n"
+					+ "It might be necessary to format (ctrl+shift+F) the model."
+				)
+			}
+		}
+		return null;
+	}
+
+	private def void migrateModel(EObject model, MigrateContext ctx) {
+		model.eAllContents.toIterable.filter(DetailCode).filter[used].forEach[
+			val ccString = lines.join(ctx.lineSep)
+			
+			used = false
+			lines.clear
+			lines += ccString
+			
+			ctx.actionCodesChanged++
+		]
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateTransitionData.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateTransitionData.xtend
new file mode 100644
index 000000000..bcde09363
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/handlers/MigrateTransitionData.xtend
@@ -0,0 +1,120 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.ui.handlers
+
+import com.google.inject.Inject
+import java.util.regex.Pattern
+import org.eclipse.core.commands.AbstractHandler
+import org.eclipse.core.commands.ExecutionEvent
+import org.eclipse.core.commands.ExecutionException
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.core.fsm.fSM.FSMFactory
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageHandler
+import org.eclipse.etrice.core.room.RoomModel
+import org.eclipse.jface.dialogs.MessageDialog
+import org.eclipse.swt.widgets.Display
+import org.eclipse.xtext.formatting.IWhitespaceInformationProvider
+import org.eclipse.xtext.resource.XtextResource
+import org.eclipse.xtext.ui.editor.utils.EditorUtils
+import org.eclipse.xtext.util.concurrent.IUnitOfWork
+
+class MigrateTransitionData extends AbstractHandler {
+
+	public static final String genericDataName = "transitionData"
+
+	@Inject
+	IWhitespaceInformationProvider whitespaceProvider;
+	
+	static class MigrateContext {
+		var String lineSep
+		var int actionCodeReplacements = 0
+	}
+	
+	override Object execute(ExecutionEvent event) throws ExecutionException {
+		
+		val proceed = MessageDialog.openQuestion(
+			Display.current.activeShell,
+			"Migrate to new style of transition data",
+			"This migration will replace textual occurrences of old data names with the generic name '" + genericDataName + "'\n\n"
+			+ "Proceed?"
+		)
+		if (proceed) {
+			val editor = EditorUtils.getActiveXtextEditor(event)
+			if (editor!==null) {
+				val ctx = editor.getDocument().modify(new IUnitOfWork<MigrateContext, XtextResource>() {
+					
+					override exec(XtextResource state) throws Exception {
+						val ctx = new MigrateContext => [
+							lineSep = whitespaceProvider.getLineSeparatorInformation(state.URI).lineSeparator
+						]
+						for (model : state.getContents()) {
+							if (model instanceof RoomModel) {
+								migrateModel(model, ctx)
+							}
+						}
+						return ctx
+					}
+					
+						
+					});
+				MessageDialog.openInformation(
+					Display.current.activeShell,
+					"Migrate to new style of transition data",
+					"Did replacements in " + ctx.actionCodeReplacements + " action codes."
+				)
+			}
+		}
+		return null;
+	}
+
+	private def void migrateModel(RoomModel model, MigrateContext ctx) {
+		// parse detail code and make replacements
+		// consider only TriggeredTransition (which is not quite accurate)
+		model.eAllContents.toIterable.filter(TriggeredTransition).forEach[
+			val msg = triggers.head?.msgFromIfPairs?.head?.message
+			if(triggers.head?.guard !== null) {
+				triggers.head.guard.guard = makeActionCodeReplacements(msg, triggers.head.guard.guard, ctx)
+			}
+			action = makeActionCodeReplacements(msg, action, ctx)
+		]
+		model.eAllContents.toIterable.filter(MessageHandler).forEach[
+			detailCode = makeActionCodeReplacements(msg, detailCode, ctx)
+		]
+	}
+	
+	private def makeActionCodeReplacements(EObject msg, DetailCode action, MigrateContext ctx) {
+		// inaccurate assumption: we can look at the first trigger message only
+		if (msg instanceof Message) {
+			if (msg.data!==null && msg.data.deprecatedName!==null && action!==null && !action.lines.empty) {
+				// we turn a multiline detail code into a single line one. Otherwise the serializer will fail because of the CC_STRING				
+				val detailCode = action.lines.join(ctx.lineSep)
+				// only full name matches
+				val matcher = Pattern.compile('''(?<![\d\w_])«msg.data.deprecatedName»(?![\d\w_])''').matcher(detailCode)
+				if(matcher.find) {
+					ctx.actionCodeReplacements += 1
+					return FSMFactory.eINSTANCE.createDetailCode => [
+						lines += matcher.replaceAll(genericDataName)
+						used = false
+					]
+				}
+			}
+		}
+		
+		// return the unchanged code
+		return action
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/HighlightingAstVisitor.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/HighlightingAstVisitor.xtend
new file mode 100644
index 000000000..f20a4621d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/HighlightingAstVisitor.xtend
@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.ui.highlight
+
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.MessageData
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.VarDecl
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOtherNode
+import org.eclipse.etrice.dctools.fsm.ast.util.IDCAstNodeVisitor
+import org.eclipse.xtext.ide.editor.syntaxcoloring.IHighlightedPositionAcceptor
+import org.eclipse.xtext.nodemodel.INode
+import org.eclipse.etrice.dctools.ast.DCUtil
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOperationCallNode
+import org.eclipse.etrice.core.room.Message
+
+class HighlightingAstVisitor implements IDCAstNodeVisitor {
+	
+	IHighlightedPositionAcceptor acceptor
+	int baseOffset
+
+	static def highlight(INode node, IHighlightedPositionAcceptor acceptor, DCUtil util) {
+		val ast = util.parseAndLink(node)
+		val offset = util.getDelimiterAdjustedOffset(node)
+		val visitor = new HighlightingAstVisitor(acceptor, offset)
+		ast.visit(visitor)
+	}
+	
+	private new(IHighlightedPositionAcceptor acceptor, int baseOffset) {
+		this.acceptor = acceptor
+		this.baseOffset = baseOffset
+	}
+
+	override boolean visitBegin(DCAstNode node) {
+		var int begin
+		var int length
+		val highlightId = switch node {
+			DCAstOtherNode: {
+				begin = node.token.begin
+				length = node.token.length
+				switch node.token.token.kind {
+					case COMMENT: RoomHighlightingConfiguration.COMMENT_ID
+					case STRING: RoomHighlightingConfiguration.STRING_ID
+					case NUMBER: RoomHighlightingConfiguration.NUMBER_ID
+					case KEYWORD: RoomHighlightingConfiguration.KEYWORD_ID
+					default: null
+				}
+			}
+			DCAstIdentifierNode: {
+				begin = node.token.begin
+				length = node.token.length
+				switch DCUtil.getLinkedObject(node) {
+					Attribute,
+					MessageData,
+					VarDecl: RoomHighlightingConfiguration.HL_EXPR_ATTRIBUTE_ID
+					InterfaceItem: RoomHighlightingConfiguration.HL_EXPR_INTERFACE_ITEM_ID
+					Operation: RoomHighlightingConfiguration.HL_EXPR_OPERATION_ID
+					default: null
+				}
+			}
+			DCAstOperationCallNode: {
+				begin = node.idNode.token.begin
+				length = node.idNode.token.length
+				switch node.linkedObject {
+					Message: RoomHighlightingConfiguration.HL_EXPR_OPERATION_ID
+					default: null
+				}
+			}
+		}
+		if (highlightId !== null) {
+			acceptor.addPosition(baseOffset + begin, length, highlightId)
+		}
+		return true
+	}
+
+	override void visitEnd(DCAstNode node) {
+	}
+}
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomHighlightingConfiguration.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomHighlightingConfiguration.java
index 2d141e887..b59fd089f 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomHighlightingConfiguration.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomHighlightingConfiguration.java
@@ -31,6 +31,10 @@ public class RoomHighlightingConfiguration extends BaseHighlightingConfig {
 	public static final String HL_EXPR_OPERATION_ID = "hl_expr_operation";
 	public static final String HL_EXPR_ATTRIBUTE_ID = "hl_expr_attribute";
 	public static final String HL_EXPR_INTERFACE_ITEM_ID = "hl_expr_interfaceitem";
+	public static final String HL_EXPR_ENUM_ID = "hl_expr_enum";
+	public static final String HL_EXPR_DATA_CLASS_ID = "hl_data_class";
+	public static final String HL_PRIMITIVE_TYPE_ID = "hl_primitve_type";
+	public static final String HL_EXTERNAL_TYPE_ID = "hl_external_type";
 
 	// default fonts used by this specific highlighting (defaults)
 	// private static FontData defaultAnnotationBlockFont = new
@@ -45,6 +49,10 @@ public class RoomHighlightingConfiguration extends BaseHighlightingConfig {
 		acceptor.acceptDefaultHighlighting(HL_EXPR_OPERATION_ID, "Expression Operation", expressionOperation());
 		acceptor.acceptDefaultHighlighting(HL_EXPR_ATTRIBUTE_ID, "Expression Attribute", expressionAttribute());
 		acceptor.acceptDefaultHighlighting(HL_EXPR_INTERFACE_ITEM_ID, "Expression Interface Item", expressionInterfaceItem());
+		acceptor.acceptDefaultHighlighting(HL_EXPR_ENUM_ID, "Expression Enum", expressionEnum());
+		acceptor.acceptDefaultHighlighting(HL_EXPR_DATA_CLASS_ID, "Expression Data Class", dataClass());
+		acceptor.acceptDefaultHighlighting(HL_PRIMITIVE_TYPE_ID, "Expression Primitive Type", primitiveType());
+		acceptor.acceptDefaultHighlighting(HL_EXTERNAL_TYPE_ID, "Expression External Type", externalType());
 	}
 
 	// method for calculating an actual text styles
@@ -80,5 +88,29 @@ public class RoomHighlightingConfiguration extends BaseHighlightingConfig {
 		textStyle.setColor(AbstractHighlightStyles.INTERFACE_ITEM_RGB);
 		return textStyle;
 	}
+	
+	public TextStyle expressionEnum() {
+		TextStyle textStyle = new TextStyle();
+		textStyle.setColor(AbstractHighlightStyles.ENUM_RGB);
+		return textStyle;
+	}
+	
+	public TextStyle dataClass() {
+		TextStyle textStyle = new TextStyle();
+		textStyle.setColor(AbstractHighlightStyles.DATA_CLASS_RGB);
+		return textStyle;
+	}
+	
+	public TextStyle primitiveType() {
+		TextStyle textStyle = new TextStyle();
+		textStyle.setColor(AbstractHighlightStyles.PRIMITIVE_TYPE_RGB);
+		return textStyle;
+	}
+	
+	public TextStyle externalType() {
+		TextStyle textStyle = new TextStyle();
+		textStyle.setColor(AbstractHighlightStyles.EXTERNAL_TYPE_RGB);
+		return textStyle;
+	}
 
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomSemanticHighlightingCalculator.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomSemanticHighlightingCalculator.java
index afbb17450..8c915a7af 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomSemanticHighlightingCalculator.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/RoomSemanticHighlightingCalculator.java
@@ -15,23 +15,18 @@ package org.eclipse.etrice.core.ui.highlight;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.common.ui.highlight.BaseSemanticHighlighter;
 import org.eclipse.etrice.core.converter.RoomValueConverterService;
-import org.eclipse.etrice.core.fsm.fSM.DetailCode;
 import org.eclipse.etrice.core.services.RoomGrammarAccess;
-import org.eclipse.etrice.core.ui.util.UIExpressionUtil;
-import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider;
-import org.eclipse.etrice.expressions.ui.highlight.ExpressionRuleFactory;
-import org.eclipse.etrice.expressions.ui.highlight.TargetLanguageRuleFactory;
-import org.eclipse.jface.text.Document;
-import org.eclipse.jface.text.rules.IRule;
-import org.eclipse.jface.text.rules.IToken;
-import org.eclipse.jface.text.rules.RuleBasedScanner;
-import org.eclipse.jface.text.rules.Token;
+import org.eclipse.etrice.dctools.ast.DCUtil;
+import org.eclipse.etrice.dctools.fsm.ast.DCLanguage;
+import org.eclipse.etrice.ui.behavior.fsm.Activator;
+import org.eclipse.etrice.ui.behavior.fsm.actioneditor.preferences.PreferenceConstants;
+import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.xtext.RuleCall;
 import org.eclipse.xtext.ide.editor.syntaxcoloring.IHighlightedPositionAcceptor;
 import org.eclipse.xtext.nodemodel.INode;
 import org.eclipse.xtext.resource.XtextResource;
+import org.eclipse.xtext.util.CancelIndicator;
 
-import com.google.common.collect.Iterables;
 import com.google.inject.Inject;
 
 /**
@@ -39,54 +34,54 @@ import com.google.inject.Inject;
  * 
  */
 public class RoomSemanticHighlightingCalculator extends BaseSemanticHighlighter {
-
-	@Inject
-	RoomGrammarAccess grammar;
 	
-	@Inject
-	RoomValueConverterService converterService;
+	@Inject RoomGrammarAccess grammar;
+	@Inject RoomValueConverterService converterService;
+	@Inject DCUtil detailCodeUtil;
+	DCLanguage language = null;
+	
+	public RoomSemanticHighlightingCalculator() {
+	}
 	
 	@Override
-	protected void provideHighlightingFor(INode node, XtextResource resource, IHighlightedPositionAcceptor acceptor) {
-		super.provideHighlightingFor(node, resource, acceptor);
+	public void provideHighlightingFor(XtextResource resource, IHighlightedPositionAcceptor acceptor, CancelIndicator cancelIndicator) {
+		if (resource == null || resource.getParseResult() == null)
+			return;
 		
-		EObject obj = node.getGrammarElement();
-		if (obj instanceof RuleCall) {
-			RuleCall ruleCall = (RuleCall) obj;
-			if(ruleCall.getRule() == grammar.getAnnotationRule()){
-				acceptor.addPosition(
-						node.getOffset(),
-						node.getLength(),
-						RoomHighlightingConfiguration.HL_ANNOTATION_ID);
-			}
-			else if(node.getParent().getSemanticElement() instanceof DetailCode && ruleCall.getRule() == grammar.getCC_STRINGRule()) {
-				detailCodeHighlight(node, acceptor);
-			}
+		if (language==null) {
+			setLanguage();
+		}
+
+		INode root = resource.getParseResult().getRootNode();
+		for (INode node : root.getAsTreeIterable()) {
+			if(cancelIndicator.isCanceled()) 
+				break;
 			
+			super.provideHighlightingFor(node, resource, acceptor);	
+			
+			EObject obj = node.getGrammarElement();
+			if (obj instanceof RuleCall) {
+				RuleCall ruleCall = (RuleCall) obj;
+				if(ruleCall.getRule() == grammar.getAnnotationRule()){
+					acceptor.addPosition(node.getOffset(), node.getLength(), RoomHighlightingConfiguration.HL_ANNOTATION_ID);
+				}
+				else if(ruleCall.getRule() == grammar.getCC_STRINGRule()) {
+					HighlightingAstVisitor.highlight(node, acceptor, detailCodeUtil);
+				}
+			}
+
 		}
-		
 	}
-	
-	protected void detailCodeHighlight(INode node, IHighlightedPositionAcceptor acceptor) {
-		final String text = converterService.getCC_StringConverter().stripDelim(node.getText());
-		final int offset = node.getOffset() + converterService.getCC_StringConverter().getDelim().length();
-		IDetailExpressionProvider exprProvider = UIExpressionUtil.selectExpressionProvider(node.getSemanticElement().eContainer());
-		XtextHighlightStyles styles = new XtextHighlightStyles();
-		RuleBasedScanner scanner = new RuleBasedScanner();
-		scanner.setRules(Iterables.toArray(Iterables.concat(
-				TargetLanguageRuleFactory.getGeneralLiteralRules(styles),
-				ExpressionRuleFactory.getInitialExpressionRules(exprProvider, styles),
-				TargetLanguageRuleFactory.getGeneralKeywordRules(styles))
-		, IRule.class));
-		scanner.setRange(new Document(text), 0, text.length());
-		
-		IToken lastToken = null;
-		while(lastToken != Token.EOF) {
-			lastToken = scanner.nextToken();
-			if(lastToken != null && lastToken.getData() != null) {
-				acceptor.addPosition(offset + scanner.getTokenOffset(), scanner.getTokenLength(), (String) lastToken.getData());
-			}
+
+	private void setLanguage() {
+		IPreferenceStore preferenceStore = Activator.getDefault().getPreferenceStore();
+		String lang = preferenceStore.getString(PreferenceConstants.EDITOR_LANGUAGE);
+		if (lang.equals(PreferenceConstants.JAVA_LANGUAGE)) {
+			language = DCLanguage.JAVA_LANGUAGE;
 		}
+		else {
+			language = DCLanguage.CPP_LANGUAGE;
+		}
+		detailCodeUtil.setLanguage(language);
 	}
-	
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/XtextHighlightStyles.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/XtextHighlightStyles.xtend
index 88e94f107..42c57dc7d 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/XtextHighlightStyles.xtend
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/highlight/XtextHighlightStyles.xtend
@@ -60,4 +60,20 @@ class XtextHighlightStyles extends AbstractHighlightStyles {
 		HL_EXPR_INTERFACE_ITEM_ID
 	}
 	
+	override getEnum() {
+		HL_EXPR_ENUM_ID
+	}
+	
+	override getDataClass() {
+		HL_EXPR_DATA_CLASS_ID
+	}
+	
+	override getPrimitiveType() {
+		HL_PRIMITIVE_TYPE_ID
+	}
+	
+	override getExternalType() {
+		HL_EXTERNAL_TYPE_ID
+	}
+	
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/hover/RoomHoverProvider.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/hover/RoomHoverProvider.xtend
index 8a0234f4c..1d61abca7 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/hover/RoomHoverProvider.xtend
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/hover/RoomHoverProvider.xtend
@@ -13,11 +13,10 @@
 package org.eclipse.etrice.core.ui.hover
 
 import com.google.inject.Inject
-import org.eclipse.emf.ecore.EObject
 import org.eclipse.etrice.core.common.ui.hover.KeywordEObjectTextHover
 import org.eclipse.etrice.core.fsm.fSM.DetailCode
 import org.eclipse.etrice.core.services.RoomGrammarAccess
-import org.eclipse.etrice.core.ui.util.UIExpressionUtil
+import org.eclipse.etrice.dctools.ast.DCUtil
 import org.eclipse.jface.text.Region
 import org.eclipse.xtext.RuleCall
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils
@@ -26,8 +25,8 @@ import org.eclipse.xtext.util.Tuples
 
 class RoomHoverProvider extends KeywordEObjectTextHover {
 	
-	@Inject
-	RoomGrammarAccess grammar
+	@Inject RoomGrammarAccess grammar
+	@Inject DCUtil util
 	
 	override protected getXtextElementAt(XtextResource resource, int offset) {
 		// lookup expression
@@ -36,9 +35,13 @@ class RoomHoverProvider extends KeywordEObjectTextHover {
 			val leafNode = NodeModelUtils.findLeafNodeAtOffset(parseResult.rootNode, offset)
 			if(leafNode?.grammarElement instanceof RuleCall) {
 				if((leafNode.grammarElement as RuleCall).rule == grammar.CC_STRINGRule && leafNode.semanticElement instanceof DetailCode){
-					val exprFeature = UIExpressionUtil.findAtOffset(leafNode, offset)
-					if(exprFeature?.data instanceof EObject)
-						return Tuples.create(exprFeature.data as EObject, new Region(offset, exprFeature.id.length))
+//					println("RoomHoverProvider at offset " + offset + " " + leafNode.offset + " " + leafNode.text.substring(offset - leafNode.offset))
+					val result = util.findAtOffset(leafNode, offset)
+					if (result!==null) {
+//						val begin = result.begin
+//						println("RoomHoverProvider hit " + (leafNode.offset + result.begin) +" " + result.length + " " + leafNode.text.substring(begin, begin + result.length))
+						return Tuples.create(result.object, new Region(leafNode.offset + result.begin, result.length))
+					}
 				}
 			}
 		}
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/labeling/RoomLabelProvider.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/labeling/RoomLabelProvider.java
index 648697b7d..9395725b8 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/labeling/RoomLabelProvider.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/labeling/RoomLabelProvider.java
@@ -36,6 +36,7 @@ import org.eclipse.etrice.core.room.ExternalType;
 import org.eclipse.etrice.core.room.LogicalSystem;
 import org.eclipse.etrice.core.room.LogicalThread;
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.Operation;
 import org.eclipse.etrice.core.room.Port;
 import org.eclipse.etrice.core.room.PortOperation;
@@ -48,7 +49,6 @@ import org.eclipse.etrice.core.room.ServiceImplementation;
 import org.eclipse.etrice.core.room.SubProtocol;
 import org.eclipse.etrice.core.room.SubSystemClass;
 import org.eclipse.etrice.core.room.SubSystemRef;
-import org.eclipse.etrice.core.room.VarDecl;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 import org.eclipse.jface.viewers.StyledString;
 
@@ -332,8 +332,8 @@ public class RoomLabelProvider extends FSMLabelProvider {
 	String text(Message m) {
 		String signature = "";
 		if (m.getData()!=null) {
-			VarDecl data = m.getData();
-			signature = data.getName()+":"+data.getRefType().getType().getName() + (data.getRefType().isRef() ? " ref" : "");
+			MessageData data = m.getData();
+			signature = data.getRefType().getType().getName() + (data.getRefType().isRef() ? " ref" : "");
 		}
 		signature = "("+signature+")";
 		return m.getName()+signature;
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/linking/RoomHyperlinkHelper.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/linking/RoomHyperlinkHelper.java
index 6e2c361e3..c04199f13 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/linking/RoomHyperlinkHelper.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/linking/RoomHyperlinkHelper.java
@@ -21,8 +21,8 @@ import org.eclipse.etrice.core.room.ActorRef;
 import org.eclipse.etrice.core.room.RefSegment;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 import org.eclipse.etrice.core.services.RoomGrammarAccess;
-import org.eclipse.etrice.core.ui.util.UIExpressionUtil;
-import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature;
+import org.eclipse.etrice.dctools.ast.DCUtil;
+import org.eclipse.etrice.dctools.ast.DCUtil.FindResult;
 import org.eclipse.jface.text.Region;
 import org.eclipse.xtext.AbstractRule;
 import org.eclipse.xtext.RuleCall;
@@ -42,6 +42,7 @@ public class RoomHyperlinkHelper extends ImportAwareHyperlinkHelper {
 
 	@Inject private RoomGrammarAccess grammar;
 	@Inject private RoomHelpers roomHelpers;
+	@Inject private DCUtil util;
 	
 	@Override
 	public void createHyperlinksByOffset(XtextResource resource, int offset, IHyperlinkAcceptor acceptor) {
@@ -67,12 +68,16 @@ public class RoomHyperlinkHelper extends ImportAwareHyperlinkHelper {
 				}
 			}
 			
-			if(leaf.getGrammarElement() instanceof RuleCall) {
-				if(((RuleCall) leaf.getGrammarElement()).getRule() == grammar.getCC_STRINGRule() && leaf.getSemanticElement() instanceof DetailCode) {
-					ExpressionFeature exprFeature = UIExpressionUtil.findAtOffset(leaf, offset);
-					if(exprFeature != null && exprFeature.getData() instanceof EObject) {
-						Region region = new Region(leaf.getOffset(), leaf.getLength());
-						createHyperlinksTo(resource, region, (EObject) exprFeature.getData(), acceptor);
+			if (leaf.getGrammarElement() instanceof RuleCall) {
+				if (((RuleCall) leaf.getGrammarElement()).getRule() == grammar.getCC_STRINGRule()
+						&& leaf.getSemanticElement() instanceof DetailCode) {
+					// System.out.println("RoomHyperlinkHelper at offset " + offset + " " + leaf.getOffset() + " " + leaf.getText().substring(offset - leaf.getOffset()));
+					FindResult result = util.findAtOffset(leaf, offset);
+					if (result != null) {
+						// int begin = result.getBegin();
+						// System.out.println("RoomHyperlinkHelper hit " + (leaf.getOffset() + result.getBegin()) +" " + result.getLength() + " " + leaf.getText().substring(begin, begin + result.getLength()));
+						Region region = new Region(leaf.getOffset() + result.getBegin(), result.getLength());
+						createHyperlinksTo(resource, region, result.getObject(), acceptor);
 					}
 				}
 			}
@@ -85,12 +90,13 @@ public class RoomHyperlinkHelper extends ImportAwareHyperlinkHelper {
 		ActorContainerClass lastAcContainer = roomHelpers.getParentContainer(aim);
 		ActorRef lastRef = null;
 		for (RefSegment ref : aim.getPath().getRefs()) {
-			for (ActorRef r : lastAcContainer.getActorRefs())
+			for (ActorRef r : lastAcContainer.getActorRefs()) {
 				if (r.getName().equals(ref.getRef())) {
 					lastRef = r;
 					lastAcContainer = lastRef.getType();
 					break;
 				}
+			}
 		}
 
 		return lastRef;
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/quickfix/RoomQuickfixProvider.java b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/quickfix/RoomQuickfixProvider.java
index 2ceeb6d05..87e35da1b 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/quickfix/RoomQuickfixProvider.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/quickfix/RoomQuickfixProvider.java
@@ -32,6 +32,7 @@ import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType;
 import org.eclipse.etrice.core.fsm.ui.quickfix.FSMQuickfixProvider;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.ActorRef;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.ReferenceType;
 import org.eclipse.etrice.core.room.StandardOperation;
 import org.eclipse.etrice.core.validation.RoomJavaValidator;
@@ -330,5 +331,16 @@ public class RoomQuickfixProvider extends FSMQuickfixProvider {
 			}
 		});
 	}
+	
+	@Fix(RoomJavaValidator.DEPRECATED_MESSAGE_DATA_NAME)
+	public void removeDeprecatedMessageDataName(final Issue issue, IssueResolutionAcceptor acceptor) {
+		acceptor.accept(issue, "Omit message data name.", "Remove the deprecated name for the message data.", "correction_change.gif", new ISemanticModification() {
+			@Override
+			public void apply(EObject element, IModificationContext context) throws Exception {
+				MessageData d = (MessageData) element;
+				d.setDeprecatedName(null);
+			}
+		});
+	}
 
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/util/UIExpressionUtil.xtend b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/util/UIExpressionUtil.xtend
index 634a9fe0b..5b6d876cd 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/util/UIExpressionUtil.xtend
+++ b/plugins/org.eclipse.etrice.core.room.ui/src/org/eclipse/etrice/core/ui/util/UIExpressionUtil.xtend
@@ -12,47 +12,105 @@
 
 package org.eclipse.etrice.core.ui.util
 
+import com.google.common.collect.ImmutableList
+import java.util.Map
 import org.eclipse.emf.ecore.EObject
-import org.eclipse.etrice.core.fsm.fSM.Guard
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
 import org.eclipse.etrice.core.room.ActorClass
-import org.eclipse.etrice.expressions.detailcode.DefaultDetailExpressionProvider
+import org.eclipse.etrice.core.room.MessageData
+import org.eclipse.etrice.core.room.RoomClass
+import org.eclipse.etrice.core.ui.RoomUiModule
 import org.eclipse.etrice.expressions.detailcode.DetailExpressionAssistParser
-import org.eclipse.etrice.expressions.detailcode.GuardDetailExpressionProvider
+import org.eclipse.etrice.expressions.detailcode.DetailExpressionProvider
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider
+import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.EmptyDetailExpressionProvider
+import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature
 import org.eclipse.jface.text.Document
 import org.eclipse.xtext.nodemodel.ILeafNode
-import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature
-import org.eclipse.etrice.core.room.Operation
-import org.eclipse.etrice.core.room.ClassStructor
 
+import static org.eclipse.xtext.EcoreUtil2.getContainerOfType
+
+/** 
+ * Utility to create and cache DetailExpressionProvider
+ */
 class UIExpressionUtil {
 
-	static def IDetailExpressionProvider selectExpressionProvider(EObject it) {
-		switch it {
-			Guard: new GuardDetailExpressionProvider(findActorClass)
-			StateGraphItem: new DefaultDetailExpressionProvider(findActorClass)
-			Operation: new DefaultDetailExpressionProvider(findActorClass)
-			ClassStructor: new GuardDetailExpressionProvider(findActorClass)
-			default: new IDetailExpressionProvider.EmptyDetailExpressionProvider
-		}
+	static class ExpressionCache {
+		val genModelAccess = new GenModelAccess
+		val Map<RoomClass, ImmutableList<ExpressionFeature>> sharedCaches = newHashMap
 	}
 
-	static def private ActorClass findActorClass(EObject model) {
-		var parent = model;
-		while (parent !== null) {
-			if (parent instanceof ActorClass) {
-				return parent as ActorClass
+	static class GenModelAccess {
+	
+		Map<ModelComponent, GraphContainer> cache = newHashMap
+		
+		def public GraphContainer get(ModelComponent mc) {
+			if(!cache.containsKey(mc)) {
+				val builder = new ExtendedFsmGenBuilder(RoomUiModule.injector);
+				val gc = builder.createTransformedModel(mc)
+				builder.withCommonData(gc)
+				cache.put(mc, gc)
 			}
-			parent = parent.eContainer();
+			
+			return cache.get(mc)
 		}
-
-		return null
+		
+	}
+	
+	/**
+	 *  DetailCode or eContainer + eContainmentReference
+	 */
+	static def IDetailExpressionProvider getExpressionProvider(EObject ctx, EReference ref, ExpressionCache cache) {		
+		if(ctx === null)
+			return new EmptyDetailExpressionProvider
+			
+		val exprProvider = RoomUiModule.getInjector().getInstance(DetailExpressionProvider) => [ prov |
+			if(ctx instanceof DetailCode) {
+				prov.owner = ctx.eContainer
+				prov.reference = ctx.eContainmentFeature as EReference
+			} else {
+				prov.owner = ctx
+				prov.reference = ref		
+			}
+		]
+		// set cache
+		val roomClass = getContainerOfType(ctx, RoomClass)
+		if(roomClass !== null) {
+			exprProvider.sharedCache = cache.sharedCaches.get(roomClass)
+			if(exprProvider.sharedCache === null)
+				cache.sharedCaches.put(roomClass, exprProvider.createAndSetSharedCache)
+		}
+		// set transitionData
+		val transition = getContainerOfType(ctx, TransitionBase)
+		if(transition !== null) {
+			if(roomClass instanceof ActorClass) {
+				val commonData = FsmGenExtensions.getLinkFor(cache.genModelAccess.get(roomClass), transition)?.commonData
+				if(commonData instanceof MessageData)
+					exprProvider.transitionEventData = commonData	
+			}
+		}
+		
+		return exprProvider
+	}
+	
+	static def IDetailExpressionProvider getExpressionProvider(DetailCode dc) {
+		return getExpressionProvider(dc, null, new ExpressionCache)
 	}
 	
+	static def IDetailExpressionProvider getExpressionProvider(EObject dcOwner, EReference dcRole) {
+		return getExpressionProvider(dcOwner, dcRole, new ExpressionCache)
+	}
+
+	
 	static def ExpressionFeature findAtOffset(ILeafNode leafNode, int offset) {
 		// work in progress - show eObject for detail code
-		val exprProvider = UIExpressionUtil.selectExpressionProvider(leafNode.semanticElement.eContainer)
+		val exprProvider = getExpressionProvider(leafNode.semanticElement, null)
 		
 		// TODO explicit support for hover info in DetailExpressionAssistParser
 		val text = leafNode.text
@@ -63,10 +121,11 @@ class UIExpressionUtil {
 			exprEndOfsset
 		}
 		val parser = new DetailExpressionAssistParser(new Document(leafNode.text), completeExprOffset, exprProvider)
-		
-		switch contextFeature : parser?.resolveLatestCompleted {
-			case null: exprProvider.initialFeatures.findFirst[id == parser.computeIdentifierPrefix(completeExprOffset)]
-			default: exprProvider.getContextFeatures(contextFeature).findFirst[id == parser.computeIdentifierPrefix(completeExprOffset)]
+		val word = parser.computeIdentifierPrefix(completeExprOffset)
+		switch contextFeature : parser.resolveLatestCompleted {
+			case null: exprProvider.initialFeatures.findFirst[id == word]
+			default: exprProvider.getContextFeatures(contextFeature).findFirst[id == word]
 		}
 	}
+
 }
diff --git a/plugins/org.eclipse.etrice.core.room.ui/templates/templates.xml b/plugins/org.eclipse.etrice.core.room.ui/templates/templates.xml
index f7c367f32..072a8ad46 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/templates/templates.xml
+++ b/plugins/org.eclipse.etrice.core.room.ui/templates/templates.xml
@@ -2,132 +2,160 @@
 <templates>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.RoomModel"
-	deleted="false" description="model skeleton" enabled="true"
-	id="model" name="RoomModel">RoomModel ${RoomModel1} {&#13;
-	LogicalSystem ${LogSys1} {&#13;
-		SubSystemRef ${subSysRef1}:${SubSysClass1} &#13;
-	}&#13;
-	SubSystemClass ${SubSysClass1} {&#13;
-		ActorRef ${actorRef1}:${ActorClass1} &#13;
-		LogicalThread defaultThread&#13;
-	}&#13;
-	ActorClass ${ActorClass1} {&#13;
-	}&#13;
-	${cursor}
-}</template>
+		deleted="false" description="model skeleton" enabled="true" id="model"
+		name="RoomModel">RoomModel ${RoomModel1} {&#13;
+		LogicalSystem ${LogSys1} {&#13;
+		SubSystemRef ${subSysRef1}:
+		${SubSysClass1:CrossReference('SubSystemRef.type')} &#13;
+		}&#13;
+		SubSystemClass ${SubSysClass1} {&#13;
+		ActorRef ${actorRef1}:
+		${ActorClass1:CrossReference('ActorRef.type')} &#13;
+		LogicalThread
+		defaultThread&#13;
+		}&#13;
+		ActorClass ${ActorClass1} {&#13;
+		}&#13;
+		${cursor}
+		}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.ActorClass"
 		deleted="false" description="actor class skeleton" enabled="true"
-		id="actor_class" name="ActorClass">${xx: Enum('ActorCommunicationType')}  ActorClass ${ActorClassName} {&#13;
-	Interface {&#13;
+		id="actor_class" name="ActorClass">${xx: Enum('ActorCommunicationType')} ActorClass
+		${ActorClassName} {&#13;
+		Interface {&#13;
 		${cursor}
-	}&#13;
-	Structure {&#13;
-	}&#13;
-	Behavior {&#13;
-	}&#13;
-}&#13;</template>
-
-	<template autoinsert="true" context="org.eclipse.etrice.core.Room.ProtocolClass"
-		deleted="false" description="protocol class skeleton" enabled="true"
-id="protocol_class" name="ProtocolClass">${xx: Enum('CommunicationType')}  ProtocolClass ${ProtocolClassName} {&#13;
-	incoming {&#13;
-		Message ${in1}(${data}:  ${type})
+		}&#13;
+		Structure {&#13;
+		}&#13;
+		Behavior {&#13;
+		}&#13;
+		}&#13;</template>
+
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.Room.ProtocolClass" deleted="false"
+		description="protocol class skeleton" enabled="true" id="protocol_class"
+		name="ProtocolClass">${xx: Enum('CommunicationType')} ProtocolClass
+		${ProtocolClassName} {&#13;
+		incoming {&#13;
+		Message ${in1}(${atype:CrossReference('RefableType.type')})
 		${cursor}
-	}&#13;
-	outgoing {&#13;
-	}&#13;
-}</template>
+		}&#13;
+		outgoing {&#13;
+		}&#13;
+		}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.DataClass"
-		deleted="false" description="data class skeleton" enabled="true"
-		id="data_class" name="DataClass">DataClass ${DataClassName} {&#13;
-	Attribute ${Attr1}: ${atype:CrossReference('Attribute.type')}
-	${cursor}
-}</template>
+		deleted="false" description="data class skeleton" enabled="true" id="data_class"
+		name="DataClass">DataClass ${DataClassName} {&#13;
+		Attribute ${Attr1}: ${atype:CrossReference('RefableType.type')}
+		${cursor}
+		}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.Message"
-		deleted="false" description="message skeleton" enabled="true"
-		id="message" name="Message">Message ${name}()&#13;
-${cursor}</template>
+		deleted="false" description="message skeleton" enabled="true" id="message"
+		name="Message">Message ${name}()&#13;
+		${cursor}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.Message"
 		deleted="false" description="Message with Data skeleton" enabled="true"
-		id="messageWithData" name="MessageWithData">Message ${name}(${param}: ${paramtype})&#13;
-${cursor}</template>
+		id="messageWithData" name="MessageWithData">Message
+		${name}(${atype:CrossReference('RefableType.type')})&#13;
+		${cursor}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.Attribute"
-		deleted="false" description="attribute skeleton" enabled="true"
-		id="attribute" name="Attribute">Attribute ${name}: ${type}&#13;
-${cursor}</template>
-
-	<template autoinsert="true" context="org.eclipse.etrice.core.Room.kw_Operation"
-		deleted="false" description="operation skeleton" enabled="true"
-		id="operation" name="Operation">Operation ${name}(${param}: ${paramtype}): ${rtype} '''&#13;
-	${cursor}&#13;
-'''</template>
-
-	<template autoinsert="true" context="org.eclipse.etrice.core.fsm.FSM.kw_State"
-		deleted="false" description="State with entry code, exit code and sub graph"
-		enabled="true" id="state" name="State">State ${name} {&#13;
-	entry {&#13;
-		""&#13;
-	}&#13;
-	exit {&#13;
-		""&#13;
-	}&#13;
-	subgraph {&#13;
-	}
-}
-${cursor}</template>
-
-	<template autoinsert="true" context="org.eclipse.etrice.core.fsm.FSM.DetailCode"
-		deleted="false" description="detail code" enabled="true" id="detail_code"
-		name="detail code"> '''&#13;
-	${cursor}&#13;
-'''</template>
+		deleted="false" description="attribute skeleton" enabled="true" id="attribute"
+		name="Attribute">Attribute ${name}:
+		${atype:CrossReference('RefableType.type')}&#13;
+		${cursor}
+	</template>
+
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.Room.kw_Operation" deleted="false"
+		description="operation skeleton" enabled="true" id="operation" name="Operation">Operation
+		${name}(${param}: ${atype:CrossReference('RefableType.type')}):
+		${rtype:CrossReference('RefableType.type')} '''&#13;
+		${cursor}&#13;
+		'''
+	</template>
+
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.fsm.FSM.kw_State" deleted="false"
+		description="State with entry code, exit code and sub graph" enabled="true"
+		id="state" name="State">State ${name} {&#13;
+		entry '''// entry code'''&#13;
+		exit '''// exit code'''&#13;
+		subgraph {&#13;
+		}
+		}
+		${cursor}
+	</template>
+
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.fsm.FSM.DetailCode" deleted="false"
+		description="detail code" enabled="true" id="detail_code" name="detail code">
+		'''&#13;
+		${cursor}&#13;
+		'''
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.kw_Port"
 		deleted="false" description="insert port" enabled="true" id="port"
 		name="Port">Port ${name}: ${protocol:CrossReference('Port.protocol')}
-${cursor}</template>
+		${cursor}
+	</template>
 
 	<template autoinsert="true"
 		context="org.eclipse.etrice.core.fsm.FSM.kw_RefinedState" deleted="false"
-		description="RefinedState" enabled="true" id="refined_state"
-		name="RefinedState">RefinedState ${base:CrossReference('RefinedState.base')} {&#13;
-	${cursor}&#13;
-}</template>
+		description="RefinedState" enabled="true" id="refined_state" name="RefinedState">RefinedState
+		${base:CrossReference('RefinedState.base')} {&#13;
+		${cursor}&#13;
+		}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.kw_SAP"
-		deleted="false" description="insert SAP" enabled="true" id="sap"
-		name="SAP">SAP ${name}: ${protocol:CrossReference('SAPRef.protocol')}
-${cursor}</template>
+		deleted="false" description="insert SAP" enabled="true" id="sap" name="SAP">
+		SAP ${name}: ${protocol:CrossReference('SAPRef.protocol')}
+		${cursor}
+	</template>
 
 	<template autoinsert="true" context="org.eclipse.etrice.core.Room.kw_SPP"
-		deleted="false" description="insert SPP" enabled="true" id="spp"
-		name="SPP">SPP ${name}: ${protocol:CrossReference('SPPRef.protocol')}
-${cursor}</template>
+		deleted="false" description="insert SPP" enabled="true" id="spp" name="SPP">
+		SPP ${name}: ${protocol:CrossReference('SPPRef.protocol')}
+		${cursor}
+	</template>
 
-	<template autoinsert="true" context="org.eclipse.etrice.core.Room.ExternalType"
-		deleted="false" description="ExternalType skeleton" enabled="true"
-		id="externalType" name="ExternalType">ExternalType ${name} -&gt; ${typeName}&#13;
-${cursor}</template>
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.Room.ExternalType" deleted="false"
+		description="ExternalType skeleton" enabled="true" id="externalType"
+		name="ExternalType">ExternalType ${name} -&gt; ${typeName}&#13;
+		${cursor}
+	</template>
 
 
-	<template autoinsert="true" context="org.eclipse.etrice.core.Room.PrimitiveType"
-		deleted="false" description="PrimitiveType skeleton" enabled="true"
-		id="primitiveType" name="PrimitiveType">PrimitiveType ${name} -&gt; ${typeName} (${typeCastName}) default "${defaultValueLiteral}"&#13;
-${cursor}</template>
+	<template autoinsert="true"
+		context="org.eclipse.etrice.core.Room.PrimitiveType" deleted="false"
+		description="PrimitiveType skeleton" enabled="true" id="primitiveType"
+		name="PrimitiveType">PrimitiveType ${name} -&gt; ${typeName} (${typeCastName}) default
+		"${defaultValueLiteral}"&#13;
+		${cursor}
+	</template>
 
 	<template autoinsert="true"
 		context="org.eclipse.etrice.core.common.Base.kw_@" deleted="false"
-		description="insert DataLogging with Gnuplot" enabled="true" id="annotation_dataLoggingGnuplot"
-		name="DataLogging">@DataLogging(pathlist="/${cursor}fullInstancePath1, /fullInstancePath2")&#13;
-@Gnuplot(format="pngcairo", outputfile="main.data.png", width=1800, height=600, fontsize=10)&#13;
-@GnuplotGraph(&#13;
-	paths="/fullInstancePath",&#13;
-	xtics=100, mxtics=4, ymin=-1.2, ymax=1.2&#13;
-)</template>
+		description="insert DataLogging with Gnuplot" enabled="true"
+		id="annotation_dataLoggingGnuplot" name="DataLogging">@DataLogging(pathlist="/${cursor}fullInstancePath1,
+		/fullInstancePath2")&#13;
+		@Gnuplot(format="pngcairo", outputfile="main.data.png", width=1800, height=600, fontsize=10)&#13;
+		@GnuplotGraph(&#13;
+		paths="/fullInstancePath",&#13;
+		xtics=100, mxtics=4, ymin=-1.2, ymax=1.2&#13;
+		)
+	</template>
 </templates>
 
diff --git a/plugins/org.eclipse.etrice.core.room/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.core.room/META-INF/MANIFEST.MF
index 726aa0673..844cca3aa 100644
--- a/plugins/org.eclipse.etrice.core.room/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.core.room/META-INF/MANIFEST.MF
@@ -20,7 +20,8 @@ Require-Bundle: org.eclipse.etrice.core.common;bundle-version="1.1.3",
  org.eclipse.emf.common;bundle-version="[2.6.0,3.0.0)",
  org.antlr.runtime;bundle-version="3.0.0",
  org.eclipse.core.resources;bundle-version="3.7.100",
- org.eclipse.core.runtime;bundle-version="3.7.0"
+ org.eclipse.core.runtime;bundle-version="3.7.0",
+ org.eclipse.etrice.core.genmodel.fsm;bundle-version="1.1.3"
 Import-Package: org.apache.log4j,
  org.eclipse.etrice.core.room
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
diff --git a/plugins/org.eclipse.etrice.core.room/build.gradle b/plugins/org.eclipse.etrice.core.room/build.gradle
index 4d776589e..4a9ff8df0 100644
--- a/plugins/org.eclipse.etrice.core.room/build.gradle
+++ b/plugins/org.eclipse.etrice.core.room/build.gradle
@@ -1,6 +1,7 @@
 dependencies {
 	compile project(':plugins:org.eclipse.etrice.core.common')
 	compile project(':plugins:org.eclipse.etrice.core.fsm')
+	compile project(':plugins:org.eclipse.etrice.core.genmodel.fsm')
 	runtime project(':plugins:org.eclipse.etrice.abstractexec.behavior')
 	
 	compile "org.eclipse.xtend:org.eclipse.xtend.lib:$versions.xtext"
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore
index 9501a7440..2f58be01a 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.ecore
@@ -162,6 +162,11 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="MessageData">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="deprecatedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="refType" eType="#//RefableType"
+        containment="true"/>
+  </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="RefableType">
     <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
       <details key="documentation" value="&lt;br>This is a type with an optional reference attribute.&#xD;&#xA;If 'ref' is {@code true} then by reference semantic is chosen.&#xD;&#xA;"/>
@@ -529,7 +534,7 @@
         <details key="documentation" value="&lt;br>By this name the message is referred to in the model.&#xD;&#xA;"/>
       </eAnnotations>
     </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="data" eType="#//VarDecl"
+    <eStructuralFeatures xsi:type="ecore:EReference" name="data" eType="#//MessageData"
         containment="true">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
         <details key="documentation" value="&lt;br>This is a reference to optional message data.&#xD;&#xA;"/>
@@ -606,17 +611,17 @@
     </eAnnotations>
     <eOperations name="getExternalEndPorts" upperBound="-1" eType="#//Port">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="body" value="EList&lt;Port> ports = new BasicEList&lt;Port>();&#xD;&#xA;for (ExternalPort ep : getExternalPorts()) {&#xD;&#xA;&#x9;ports.add(ep.getInterfacePort());&#xD;&#xA;}&#xD;&#xA;return ports;&#xD;&#xA;"/>
+        <details key="body" value="EList&lt;Port> ports = new BasicEList&lt;Port>();&#xD;&#xA;for (ExternalPort ep : getExternalPorts()) {&#xD;&#xA;&#x9;if(ep.getInterfacePort() != null)&#xD;&#xA;&#x9;&#x9;ports.add(ep.getInterfacePort());&#xD;&#xA;}&#xD;&#xA;return ports;&#xD;&#xA;"/>
       </eAnnotations>
     </eOperations>
     <eOperations name="getRelayPorts" upperBound="-1" eType="#//Port">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="body" value="EList&lt;Port> ports = new BasicEList&lt;Port>(getInterfacePorts());&#xD;&#xA;for (ExternalPort ep : getExternalPorts()) {&#xD;&#xA;&#x9;ports.remove(ep.getInterfacePort());&#xD;&#xA;}&#xD;&#xA;return ports;&#xD;&#xA;"/>
+        <details key="body" value="EList&lt;Port> ports = new BasicEList&lt;Port>(getInterfacePorts());&#xD;&#xA;for (ExternalPort ep : getExternalPorts()) {&#xD;&#xA;&#x9;if(ep.getInterfacePort() != null)&#xD;&#xA;&#x9;&#x9;ports.remove(ep.getInterfacePort());&#xD;&#xA;}&#xD;&#xA;return ports;&#xD;&#xA;"/>
       </eAnnotations>
     </eOperations>
     <eOperations name="getImplementedSPPs" upperBound="-1" eType="#//SPP">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="body" value="EList&lt;SPP> spps = new BasicEList&lt;SPP>();&#xD;&#xA;for (ServiceImplementation spp : getServiceImplementations()) {&#xD;&#xA;&#x9;spps.add(spp.getSpp());&#xD;&#xA;}&#xD;&#xA;return spps;&#xD;&#xA;"/>
+        <details key="body" value="EList&lt;SPP> spps = new BasicEList&lt;SPP>();&#xD;&#xA;for (ServiceImplementation spp : getServiceImplementations()) {&#xD;&#xA;&#x9;if(spp.getSpp() != null)&#xD;&#xA;&#x9;&#x9;spps.add(spp.getSpp());&#xD;&#xA;}&#xD;&#xA;return spps;&#xD;&#xA;"/>
       </eAnnotations>
     </eOperations>
     <eOperations name="getActorBase" eType="#//ActorClass">
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.genmodel b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.genmodel
index d43292726..9f39845c5 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.genmodel
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.genmodel
@@ -4,7 +4,7 @@
     editorDirectory="/org.eclipse.etrice.core.room.editor/src" modelPluginID="org.eclipse.etrice.core.room"
     forceOverwrite="true" modelName="Room" updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     complianceLevel="6.0" copyrightFields="false" editPluginID="org.eclipse.etrice.core.room.edit"
-    editorPluginID="org.eclipse.etrice.core.room.editor" runtimeVersion="2.12" usedGenPackages="platform:/resource/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/Base.genmodel#//base platform:/resource/org.eclipse.etrice.core.fsm/model/generated/FSM.genmodel#//fSM">
+    editorPluginID="org.eclipse.etrice.core.room.editor" runtimeVersion="2.13" usedGenPackages="platform:/resource/org.eclipse.etrice.core.common/src-gen/org/eclipse/etrice/core/common/Base.genmodel#//base platform:/resource/org.eclipse.etrice.core.fsm/model/generated/FSM.genmodel#//fSM">
   <genPackages prefix="Room" basePackage="org.eclipse.etrice.core" disposableProviderFactory="true"
       ecorePackage="Room.ecore#/">
     <genEnums typeSafeEnumCompatible="false" ecoreEnum="Room.ecore#//CommunicationType">
@@ -61,6 +61,10 @@
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute Room.ecore#//VarDecl/name"/>
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference Room.ecore#//VarDecl/refType"/>
     </genClasses>
+    <genClasses ecoreClass="Room.ecore#//MessageData">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute Room.ecore#//MessageData/deprecatedName"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference Room.ecore#//MessageData/refType"/>
+    </genClasses>
     <genClasses ecoreClass="Room.ecore#//RefableType">
       <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference Room.ecore#//RefableType/type"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute Room.ecore#//RefableType/ref"/>
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.xtextbin b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.xtextbin
index 52a59f850..66d6451ce 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.xtextbin
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/Room.xtextbin
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoom.g b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoom.g
index 34c941660..5059b2b47 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoom.g
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoom.g
@@ -464,6 +464,67 @@ ruleVarDecl returns [EObject current=null]
 
 
 
+// Entry rule entryRuleMessageData
+entryRuleMessageData returns [EObject current=null] 
+	:
+	{ newCompositeNode(grammarAccess.getMessageDataRule()); }
+	 iv_ruleMessageData=ruleMessageData 
+	 { $current=$iv_ruleMessageData.current; } 
+	 EOF 
+;
+
+// Rule MessageData
+ruleMessageData returns [EObject current=null] 
+    @init { enterRule(); 
+    }
+    @after { leaveRule(); }:
+(((
+(
+		lv_deprecatedName_0_0=RULE_ID
+		{
+			newLeafNode(lv_deprecatedName_0_0, grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); 
+		}
+		{
+	        if ($current==null) {
+	            $current = createModelElement(grammarAccess.getMessageDataRule());
+	        }
+       		setWithLastConsumed(
+       			$current, 
+       			"deprecatedName",
+        		lv_deprecatedName_0_0, 
+        		"org.eclipse.xtext.common.Terminals.ID");
+	    }
+
+)
+)	otherlv_1=':' 
+    {
+    	newLeafNode(otherlv_1, grammarAccess.getMessageDataAccess().getColonKeyword_0_1());
+    }
+)?(
+(
+		{ 
+	        newCompositeNode(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); 
+	    }
+		lv_refType_2_0=ruleRefableType		{
+	        if ($current==null) {
+	            $current = createModelElementForParent(grammarAccess.getMessageDataRule());
+	        }
+       		set(
+       			$current, 
+       			"refType",
+        		lv_refType_2_0, 
+        		"org.eclipse.etrice.core.Room.RefableType");
+	        afterParserOrEnumRuleCall();
+	    }
+
+)
+))
+;
+
+
+
+
+
 // Entry rule entryRuleRefableType
 entryRuleRefableType returns [EObject current=null] 
 	:
@@ -2401,16 +2462,16 @@ ruleMessage returns [EObject current=null]
 	    }
 
 )
-)	otherlv_3='(' 
+)(	otherlv_3='(' 
     {
-    	newLeafNode(otherlv_3, grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3());
+    	newLeafNode(otherlv_3, grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0());
     }
 (
 (
 		{ 
-	        newCompositeNode(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); 
+	        newCompositeNode(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); 
 	    }
-		lv_data_4_0=ruleVarDecl		{
+		lv_data_4_0=ruleMessageData		{
 	        if ($current==null) {
 	            $current = createModelElementForParent(grammarAccess.getMessageRule());
 	        }
@@ -2418,19 +2479,19 @@ ruleMessage returns [EObject current=null]
        			$current, 
        			"data",
         		lv_data_4_0, 
-        		"org.eclipse.etrice.core.Room.VarDecl");
+        		"org.eclipse.etrice.core.Room.MessageData");
 	        afterParserOrEnumRuleCall();
 	    }
 
 )
 )?	otherlv_5=')' 
     {
-    	newLeafNode(otherlv_5, grammarAccess.getMessageAccess().getRightParenthesisKeyword_5());
+    	newLeafNode(otherlv_5, grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2());
     }
-(
+)?(
 (
 		{ 
-	        newCompositeNode(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
+	        newCompositeNode(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
 	    }
 		lv_annotations_6_0=ruleAnnotation		{
 	        if ($current==null) {
@@ -2448,7 +2509,7 @@ ruleMessage returns [EObject current=null]
 )*(
 (
 		{ 
-	        newCompositeNode(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); 
+	        newCompositeNode(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); 
 	    }
 		lv_docu_7_0=ruleDocumentation		{
 	        if ($current==null) {
@@ -6119,6 +6180,44 @@ ruleChoicePoint returns [EObject current=null]
 
 
 
+// Entry rule entryRuleTransitionBase
+entryRuleTransitionBase returns [EObject current=null] 
+	:
+	{ newCompositeNode(grammarAccess.getTransitionBaseRule()); }
+	 iv_ruleTransitionBase=ruleTransitionBase 
+	 { $current=$iv_ruleTransitionBase.current; } 
+	 EOF 
+;
+
+// Rule TransitionBase
+ruleTransitionBase returns [EObject current=null] 
+    @init { enterRule(); 
+    }
+    @after { leaveRule(); }:
+(
+    { 
+        newCompositeNode(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+    }
+    this_Transition_0=ruleTransition
+    { 
+        $current = $this_Transition_0.current; 
+        afterParserOrEnumRuleCall();
+    }
+
+    |
+    { 
+        newCompositeNode(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+    }
+    this_RefinedTransition_1=ruleRefinedTransition
+    { 
+        $current = $this_RefinedTransition_1.current; 
+        afterParserOrEnumRuleCall();
+    }
+)
+;
+
+
+
 
 
 // Entry rule entryRuleTransition
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomLexer.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomLexer.java
index 7c82b1326..67b4e5454 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomLexer.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomLexer.java
@@ -2661,10 +2661,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_HEX;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9215:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
-            // InternalRoom.g:9215:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalRoom.g:9314:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalRoom.g:9314:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalRoom.g:9215:12: ( '0x' | '0X' )
+            // InternalRoom.g:9314:12: ( '0x' | '0X' )
             int alt1=2;
             int LA1_0 = input.LA(1);
 
@@ -2692,7 +2692,7 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt1) {
                 case 1 :
-                    // InternalRoom.g:9215:13: '0x'
+                    // InternalRoom.g:9314:13: '0x'
                     {
                     match("0x"); 
 
@@ -2700,7 +2700,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9215:18: '0X'
+                    // InternalRoom.g:9314:18: '0X'
                     {
                     match("0X"); 
 
@@ -2710,7 +2710,7 @@ public class InternalRoomLexer extends Lexer {
 
             }
 
-            // InternalRoom.g:9215:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
+            // InternalRoom.g:9314:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             int cnt2=0;
             loop2:
             do {
@@ -2764,12 +2764,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_CC_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9217:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
-            // InternalRoom.g:9217:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+            // InternalRoom.g:9316:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalRoom.g:9316:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalRoom.g:9217:27: ( options {greedy=false; } : . )*
+            // InternalRoom.g:9316:27: ( options {greedy=false; } : . )*
             loop3:
             do {
                 int alt3=2;
@@ -2803,7 +2803,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt3) {
             	case 1 :
-            	    // InternalRoom.g:9217:55: .
+            	    // InternalRoom.g:9316:55: .
             	    {
             	    matchAny(); 
 
@@ -2833,10 +2833,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ID;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9219:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
-            // InternalRoom.g:9219:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalRoom.g:9318:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalRoom.g:9318:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalRoom.g:9219:11: ( '^' )?
+            // InternalRoom.g:9318:11: ( '^' )?
             int alt4=2;
             int LA4_0 = input.LA(1);
 
@@ -2845,7 +2845,7 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt4) {
                 case 1 :
-                    // InternalRoom.g:9219:11: '^'
+                    // InternalRoom.g:9318:11: '^'
                     {
                     match('^'); 
 
@@ -2863,7 +2863,7 @@ public class InternalRoomLexer extends Lexer {
                 recover(mse);
                 throw mse;}
 
-            // InternalRoom.g:9219:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            // InternalRoom.g:9318:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             loop5:
             do {
                 int alt5=2;
@@ -2912,10 +2912,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_INT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9221:10: ( ( '0' .. '9' )+ )
-            // InternalRoom.g:9221:12: ( '0' .. '9' )+
+            // InternalRoom.g:9320:10: ( ( '0' .. '9' )+ )
+            // InternalRoom.g:9320:12: ( '0' .. '9' )+
             {
-            // InternalRoom.g:9221:12: ( '0' .. '9' )+
+            // InternalRoom.g:9320:12: ( '0' .. '9' )+
             int cnt6=0;
             loop6:
             do {
@@ -2929,7 +2929,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt6) {
             	case 1 :
-            	    // InternalRoom.g:9221:13: '0' .. '9'
+            	    // InternalRoom.g:9320:13: '0' .. '9'
             	    {
             	    matchRange('0','9'); 
 
@@ -2961,10 +2961,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_STRING;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9223:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
-            // InternalRoom.g:9223:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:9322:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalRoom.g:9322:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalRoom.g:9223:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:9322:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -2982,10 +2982,10 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalRoom.g:9223:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+                    // InternalRoom.g:9322:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalRoom.g:9223:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalRoom.g:9322:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
                     loop7:
                     do {
                         int alt7=3;
@@ -3001,7 +3001,7 @@ public class InternalRoomLexer extends Lexer {
 
                         switch (alt7) {
                     	case 1 :
-                    	    // InternalRoom.g:9223:21: '\\\\' .
+                    	    // InternalRoom.g:9322:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3009,7 +3009,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:9223:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalRoom.g:9322:28: ~ ( ( '\\\\' | '\"' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -3034,10 +3034,10 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9223:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
+                    // InternalRoom.g:9322:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalRoom.g:9223:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalRoom.g:9322:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
                     loop8:
                     do {
                         int alt8=3;
@@ -3053,7 +3053,7 @@ public class InternalRoomLexer extends Lexer {
 
                         switch (alt8) {
                     	case 1 :
-                    	    // InternalRoom.g:9223:54: '\\\\' .
+                    	    // InternalRoom.g:9322:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3061,7 +3061,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:9223:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalRoom.g:9322:61: ~ ( ( '\\\\' | '\\'' ) )
                     	    {
                     	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                     	        input.consume();
@@ -3104,12 +3104,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ML_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9225:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
-            // InternalRoom.g:9225:19: '/*' ( options {greedy=false; } : . )* '*/'
+            // InternalRoom.g:9324:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalRoom.g:9324:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalRoom.g:9225:24: ( options {greedy=false; } : . )*
+            // InternalRoom.g:9324:24: ( options {greedy=false; } : . )*
             loop10:
             do {
                 int alt10=2;
@@ -3134,7 +3134,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt10) {
             	case 1 :
-            	    // InternalRoom.g:9225:52: .
+            	    // InternalRoom.g:9324:52: .
             	    {
             	    matchAny(); 
 
@@ -3164,12 +3164,12 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_SL_COMMENT;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9227:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
-            // InternalRoom.g:9227:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            // InternalRoom.g:9326:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalRoom.g:9326:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalRoom.g:9227:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalRoom.g:9326:24: (~ ( ( '\\n' | '\\r' ) ) )*
             loop11:
             do {
                 int alt11=2;
@@ -3182,7 +3182,7 @@ public class InternalRoomLexer extends Lexer {
 
                 switch (alt11) {
             	case 1 :
-            	    // InternalRoom.g:9227:24: ~ ( ( '\\n' | '\\r' ) )
+            	    // InternalRoom.g:9326:24: ~ ( ( '\\n' | '\\r' ) )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -3202,7 +3202,7 @@ public class InternalRoomLexer extends Lexer {
                 }
             } while (true);
 
-            // InternalRoom.g:9227:40: ( ( '\\r' )? '\\n' )?
+            // InternalRoom.g:9326:40: ( ( '\\r' )? '\\n' )?
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -3211,9 +3211,9 @@ public class InternalRoomLexer extends Lexer {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalRoom.g:9227:41: ( '\\r' )? '\\n'
+                    // InternalRoom.g:9326:41: ( '\\r' )? '\\n'
                     {
-                    // InternalRoom.g:9227:41: ( '\\r' )?
+                    // InternalRoom.g:9326:41: ( '\\r' )?
                     int alt12=2;
                     int LA12_0 = input.LA(1);
 
@@ -3222,7 +3222,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     switch (alt12) {
                         case 1 :
-                            // InternalRoom.g:9227:41: '\\r'
+                            // InternalRoom.g:9326:41: '\\r'
                             {
                             match('\r'); 
 
@@ -3254,10 +3254,10 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_WS;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9229:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
-            // InternalRoom.g:9229:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:9328:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalRoom.g:9328:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalRoom.g:9229:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:9328:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             int cnt14=0;
             loop14:
             do {
@@ -3311,8 +3311,8 @@ public class InternalRoomLexer extends Lexer {
         try {
             int _type = RULE_ANY_OTHER;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // InternalRoom.g:9231:16: ( . )
-            // InternalRoom.g:9231:18: .
+            // InternalRoom.g:9330:16: ( . )
+            // InternalRoom.g:9330:18: .
             {
             matchAny(); 
 
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomParser.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomParser.java
index 9b6c810fb..8b4e52ed0 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomParser.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/parser/antlr/internal/InternalRoomParser.java
@@ -1156,8 +1156,165 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     // $ANTLR end "ruleVarDecl"
 
 
+    // $ANTLR start "entryRuleMessageData"
+    // InternalRoom.g:468:1: entryRuleMessageData returns [EObject current=null] : iv_ruleMessageData= ruleMessageData EOF ;
+    public final EObject entryRuleMessageData() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleMessageData = null;
+
+
+        try {
+            // InternalRoom.g:469:2: (iv_ruleMessageData= ruleMessageData EOF )
+            // InternalRoom.g:470:2: iv_ruleMessageData= ruleMessageData EOF
+            {
+             newCompositeNode(grammarAccess.getMessageDataRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleMessageData=ruleMessageData();
+
+            state._fsp--;
+
+             current =iv_ruleMessageData; 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleMessageData"
+
+
+    // $ANTLR start "ruleMessageData"
+    // InternalRoom.g:477:1: ruleMessageData returns [EObject current=null] : ( ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )? ( (lv_refType_2_0= ruleRefableType ) ) ) ;
+    public final EObject ruleMessageData() throws RecognitionException {
+        EObject current = null;
+
+        Token lv_deprecatedName_0_0=null;
+        Token otherlv_1=null;
+        EObject lv_refType_2_0 = null;
+
+
+         enterRule(); 
+            
+        try {
+            // InternalRoom.g:480:28: ( ( ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )? ( (lv_refType_2_0= ruleRefableType ) ) ) )
+            // InternalRoom.g:481:1: ( ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )? ( (lv_refType_2_0= ruleRefableType ) ) )
+            {
+            // InternalRoom.g:481:1: ( ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )? ( (lv_refType_2_0= ruleRefableType ) ) )
+            // InternalRoom.g:481:2: ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )? ( (lv_refType_2_0= ruleRefableType ) )
+            {
+            // InternalRoom.g:481:2: ( ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':' )?
+            int alt6=2;
+            int LA6_0 = input.LA(1);
+
+            if ( (LA6_0==RULE_ID) ) {
+                int LA6_1 = input.LA(2);
+
+                if ( (LA6_1==16) ) {
+                    alt6=1;
+                }
+            }
+            switch (alt6) {
+                case 1 :
+                    // InternalRoom.g:481:3: ( (lv_deprecatedName_0_0= RULE_ID ) ) otherlv_1= ':'
+                    {
+                    // InternalRoom.g:481:3: ( (lv_deprecatedName_0_0= RULE_ID ) )
+                    // InternalRoom.g:482:1: (lv_deprecatedName_0_0= RULE_ID )
+                    {
+                    // InternalRoom.g:482:1: (lv_deprecatedName_0_0= RULE_ID )
+                    // InternalRoom.g:483:3: lv_deprecatedName_0_0= RULE_ID
+                    {
+                    lv_deprecatedName_0_0=(Token)match(input,RULE_ID,FOLLOW_8); 
+
+                    			newLeafNode(lv_deprecatedName_0_0, grammarAccess.getMessageDataAccess().getDeprecatedNameIDTerminalRuleCall_0_0_0()); 
+                    		
+
+                    	        if (current==null) {
+                    	            current = createModelElement(grammarAccess.getMessageDataRule());
+                    	        }
+                           		setWithLastConsumed(
+                           			current, 
+                           			"deprecatedName",
+                            		lv_deprecatedName_0_0, 
+                            		"org.eclipse.xtext.common.Terminals.ID");
+                    	    
+
+                    }
+
+
+                    }
+
+                    otherlv_1=(Token)match(input,16,FOLLOW_3); 
+
+                        	newLeafNode(otherlv_1, grammarAccess.getMessageDataAccess().getColonKeyword_0_1());
+                        
+
+                    }
+                    break;
+
+            }
+
+            // InternalRoom.g:503:3: ( (lv_refType_2_0= ruleRefableType ) )
+            // InternalRoom.g:504:1: (lv_refType_2_0= ruleRefableType )
+            {
+            // InternalRoom.g:504:1: (lv_refType_2_0= ruleRefableType )
+            // InternalRoom.g:505:3: lv_refType_2_0= ruleRefableType
+            {
+             
+            	        newCompositeNode(grammarAccess.getMessageDataAccess().getRefTypeRefableTypeParserRuleCall_1_0()); 
+            	    
+            pushFollow(FOLLOW_2);
+            lv_refType_2_0=ruleRefableType();
+
+            state._fsp--;
+
+
+            	        if (current==null) {
+            	            current = createModelElementForParent(grammarAccess.getMessageDataRule());
+            	        }
+                   		set(
+                   			current, 
+                   			"refType",
+                    		lv_refType_2_0, 
+                    		"org.eclipse.etrice.core.Room.RefableType");
+            	        afterParserOrEnumRuleCall();
+            	    
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+             leaveRule(); 
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleMessageData"
+
+
     // $ANTLR start "entryRuleRefableType"
-    // InternalRoom.g:468:1: entryRuleRefableType returns [EObject current=null] : iv_ruleRefableType= ruleRefableType EOF ;
+    // InternalRoom.g:529:1: entryRuleRefableType returns [EObject current=null] : iv_ruleRefableType= ruleRefableType EOF ;
     public final EObject entryRuleRefableType() throws RecognitionException {
         EObject current = null;
 
@@ -1165,8 +1322,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:469:2: (iv_ruleRefableType= ruleRefableType EOF )
-            // InternalRoom.g:470:2: iv_ruleRefableType= ruleRefableType EOF
+            // InternalRoom.g:530:2: (iv_ruleRefableType= ruleRefableType EOF )
+            // InternalRoom.g:531:2: iv_ruleRefableType= ruleRefableType EOF
             {
              newCompositeNode(grammarAccess.getRefableTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -1193,7 +1350,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefableType"
-    // InternalRoom.g:477:1: ruleRefableType returns [EObject current=null] : ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? ) ;
+    // InternalRoom.g:538:1: ruleRefableType returns [EObject current=null] : ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? ) ;
     public final EObject ruleRefableType() throws RecognitionException {
         EObject current = null;
 
@@ -1202,17 +1359,17 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:480:28: ( ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? ) )
-            // InternalRoom.g:481:1: ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? )
+            // InternalRoom.g:541:28: ( ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? ) )
+            // InternalRoom.g:542:1: ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? )
             {
-            // InternalRoom.g:481:1: ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? )
-            // InternalRoom.g:481:2: ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )?
+            // InternalRoom.g:542:1: ( ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )? )
+            // InternalRoom.g:542:2: ( ( ruleFQN ) ) ( (lv_ref_1_0= 'ref' ) )?
             {
-            // InternalRoom.g:481:2: ( ( ruleFQN ) )
-            // InternalRoom.g:482:1: ( ruleFQN )
+            // InternalRoom.g:542:2: ( ( ruleFQN ) )
+            // InternalRoom.g:543:1: ( ruleFQN )
             {
-            // InternalRoom.g:482:1: ( ruleFQN )
-            // InternalRoom.g:483:3: ruleFQN
+            // InternalRoom.g:543:1: ( ruleFQN )
+            // InternalRoom.g:544:3: ruleFQN
             {
 
             			if (current==null) {
@@ -1236,19 +1393,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:496:2: ( (lv_ref_1_0= 'ref' ) )?
-            int alt6=2;
-            int LA6_0 = input.LA(1);
+            // InternalRoom.g:557:2: ( (lv_ref_1_0= 'ref' ) )?
+            int alt7=2;
+            int LA7_0 = input.LA(1);
 
-            if ( (LA6_0==17) ) {
-                alt6=1;
+            if ( (LA7_0==17) ) {
+                alt7=1;
             }
-            switch (alt6) {
+            switch (alt7) {
                 case 1 :
-                    // InternalRoom.g:497:1: (lv_ref_1_0= 'ref' )
+                    // InternalRoom.g:558:1: (lv_ref_1_0= 'ref' )
                     {
-                    // InternalRoom.g:497:1: (lv_ref_1_0= 'ref' )
-                    // InternalRoom.g:498:3: lv_ref_1_0= 'ref'
+                    // InternalRoom.g:558:1: (lv_ref_1_0= 'ref' )
+                    // InternalRoom.g:559:3: lv_ref_1_0= 'ref'
                     {
                     lv_ref_1_0=(Token)match(input,17,FOLLOW_2); 
 
@@ -1290,7 +1447,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDataType"
-    // InternalRoom.g:519:1: entryRuleDataType returns [EObject current=null] : iv_ruleDataType= ruleDataType EOF ;
+    // InternalRoom.g:580:1: entryRuleDataType returns [EObject current=null] : iv_ruleDataType= ruleDataType EOF ;
     public final EObject entryRuleDataType() throws RecognitionException {
         EObject current = null;
 
@@ -1298,8 +1455,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:520:2: (iv_ruleDataType= ruleDataType EOF )
-            // InternalRoom.g:521:2: iv_ruleDataType= ruleDataType EOF
+            // InternalRoom.g:581:2: (iv_ruleDataType= ruleDataType EOF )
+            // InternalRoom.g:582:2: iv_ruleDataType= ruleDataType EOF
             {
              newCompositeNode(grammarAccess.getDataTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -1326,7 +1483,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDataType"
-    // InternalRoom.g:528:1: ruleDataType returns [EObject current=null] : (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType ) ;
+    // InternalRoom.g:589:1: ruleDataType returns [EObject current=null] : (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType ) ;
     public final EObject ruleDataType() throws RecognitionException {
         EObject current = null;
 
@@ -1340,38 +1497,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:531:28: ( (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType ) )
-            // InternalRoom.g:532:1: (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType )
+            // InternalRoom.g:592:28: ( (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType ) )
+            // InternalRoom.g:593:1: (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType )
             {
-            // InternalRoom.g:532:1: (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType )
-            int alt7=3;
+            // InternalRoom.g:593:1: (this_PrimitiveType_0= rulePrimitiveType | this_EnumerationType_1= ruleEnumerationType | this_ComplexType_2= ruleComplexType )
+            int alt8=3;
             switch ( input.LA(1) ) {
             case 18:
                 {
-                alt7=1;
+                alt8=1;
                 }
                 break;
             case 23:
                 {
-                alt7=2;
+                alt8=2;
                 }
                 break;
             case 27:
             case 28:
                 {
-                alt7=3;
+                alt8=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 7, 0, input);
+                    new NoViableAltException("", 8, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt7) {
+            switch (alt8) {
                 case 1 :
-                    // InternalRoom.g:533:5: this_PrimitiveType_0= rulePrimitiveType
+                    // InternalRoom.g:594:5: this_PrimitiveType_0= rulePrimitiveType
                     {
                      
                             newCompositeNode(grammarAccess.getDataTypeAccess().getPrimitiveTypeParserRuleCall_0()); 
@@ -1389,7 +1546,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:543:5: this_EnumerationType_1= ruleEnumerationType
+                    // InternalRoom.g:604:5: this_EnumerationType_1= ruleEnumerationType
                     {
                      
                             newCompositeNode(grammarAccess.getDataTypeAccess().getEnumerationTypeParserRuleCall_1()); 
@@ -1407,7 +1564,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:553:5: this_ComplexType_2= ruleComplexType
+                    // InternalRoom.g:614:5: this_ComplexType_2= ruleComplexType
                     {
                      
                             newCompositeNode(grammarAccess.getDataTypeAccess().getComplexTypeParserRuleCall_2()); 
@@ -1445,7 +1602,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleComplexType"
-    // InternalRoom.g:569:1: entryRuleComplexType returns [EObject current=null] : iv_ruleComplexType= ruleComplexType EOF ;
+    // InternalRoom.g:630:1: entryRuleComplexType returns [EObject current=null] : iv_ruleComplexType= ruleComplexType EOF ;
     public final EObject entryRuleComplexType() throws RecognitionException {
         EObject current = null;
 
@@ -1453,8 +1610,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:570:2: (iv_ruleComplexType= ruleComplexType EOF )
-            // InternalRoom.g:571:2: iv_ruleComplexType= ruleComplexType EOF
+            // InternalRoom.g:631:2: (iv_ruleComplexType= ruleComplexType EOF )
+            // InternalRoom.g:632:2: iv_ruleComplexType= ruleComplexType EOF
             {
              newCompositeNode(grammarAccess.getComplexTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -1481,7 +1638,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleComplexType"
-    // InternalRoom.g:578:1: ruleComplexType returns [EObject current=null] : (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType ) ;
+    // InternalRoom.g:639:1: ruleComplexType returns [EObject current=null] : (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType ) ;
     public final EObject ruleComplexType() throws RecognitionException {
         EObject current = null;
 
@@ -1493,28 +1650,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:581:28: ( (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType ) )
-            // InternalRoom.g:582:1: (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType )
+            // InternalRoom.g:642:28: ( (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType ) )
+            // InternalRoom.g:643:1: (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType )
             {
-            // InternalRoom.g:582:1: (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType )
-            int alt8=2;
-            int LA8_0 = input.LA(1);
+            // InternalRoom.g:643:1: (this_DataClass_0= ruleDataClass | this_ExternalType_1= ruleExternalType )
+            int alt9=2;
+            int LA9_0 = input.LA(1);
 
-            if ( (LA8_0==28) ) {
-                alt8=1;
+            if ( (LA9_0==28) ) {
+                alt9=1;
             }
-            else if ( (LA8_0==27) ) {
-                alt8=2;
+            else if ( (LA9_0==27) ) {
+                alt9=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 8, 0, input);
+                    new NoViableAltException("", 9, 0, input);
 
                 throw nvae;
             }
-            switch (alt8) {
+            switch (alt9) {
                 case 1 :
-                    // InternalRoom.g:583:5: this_DataClass_0= ruleDataClass
+                    // InternalRoom.g:644:5: this_DataClass_0= ruleDataClass
                     {
                      
                             newCompositeNode(grammarAccess.getComplexTypeAccess().getDataClassParserRuleCall_0()); 
@@ -1532,7 +1689,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:593:5: this_ExternalType_1= ruleExternalType
+                    // InternalRoom.g:654:5: this_ExternalType_1= ruleExternalType
                     {
                      
                             newCompositeNode(grammarAccess.getComplexTypeAccess().getExternalTypeParserRuleCall_1()); 
@@ -1570,7 +1727,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRulePrimitiveType"
-    // InternalRoom.g:609:1: entryRulePrimitiveType returns [EObject current=null] : iv_rulePrimitiveType= rulePrimitiveType EOF ;
+    // InternalRoom.g:670:1: entryRulePrimitiveType returns [EObject current=null] : iv_rulePrimitiveType= rulePrimitiveType EOF ;
     public final EObject entryRulePrimitiveType() throws RecognitionException {
         EObject current = null;
 
@@ -1578,8 +1735,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:610:2: (iv_rulePrimitiveType= rulePrimitiveType EOF )
-            // InternalRoom.g:611:2: iv_rulePrimitiveType= rulePrimitiveType EOF
+            // InternalRoom.g:671:2: (iv_rulePrimitiveType= rulePrimitiveType EOF )
+            // InternalRoom.g:672:2: iv_rulePrimitiveType= rulePrimitiveType EOF
             {
              newCompositeNode(grammarAccess.getPrimitiveTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -1606,7 +1763,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "rulePrimitiveType"
-    // InternalRoom.g:618:1: rulePrimitiveType returns [EObject current=null] : (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:679:1: rulePrimitiveType returns [EObject current=null] : (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? ) ;
     public final EObject rulePrimitiveType() throws RecognitionException {
         EObject current = null;
 
@@ -1629,21 +1786,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:621:28: ( (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:622:1: (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? )
+            // InternalRoom.g:682:28: ( (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:683:1: (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:622:1: (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? )
-            // InternalRoom.g:622:3: otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )?
+            // InternalRoom.g:683:1: (otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )? )
+            // InternalRoom.g:683:3: otherlv_0= 'PrimitiveType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( (lv_type_3_0= ruleLiteralType ) ) otherlv_4= '->' ( (lv_targetName_5_0= RULE_STRING ) ) (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )? otherlv_9= 'default' ( (lv_defaultValueLiteral_10_0= RULE_STRING ) ) ( (lv_docu_11_0= ruleDocumentation ) )?
             {
             otherlv_0=(Token)match(input,18,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getPrimitiveTypeAccess().getPrimitiveTypeKeyword_0());
                 
-            // InternalRoom.g:626:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:627:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:687:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:688:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:627:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:628:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:688:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:689:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -1669,11 +1826,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getPrimitiveTypeAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:648:1: ( (lv_type_3_0= ruleLiteralType ) )
-            // InternalRoom.g:649:1: (lv_type_3_0= ruleLiteralType )
+            // InternalRoom.g:709:1: ( (lv_type_3_0= ruleLiteralType ) )
+            // InternalRoom.g:710:1: (lv_type_3_0= ruleLiteralType )
             {
-            // InternalRoom.g:649:1: (lv_type_3_0= ruleLiteralType )
-            // InternalRoom.g:650:3: lv_type_3_0= ruleLiteralType
+            // InternalRoom.g:710:1: (lv_type_3_0= ruleLiteralType )
+            // InternalRoom.g:711:3: lv_type_3_0= ruleLiteralType
             {
              
             	        newCompositeNode(grammarAccess.getPrimitiveTypeAccess().getTypeLiteralTypeEnumRuleCall_3_0()); 
@@ -1704,11 +1861,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getPrimitiveTypeAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:670:1: ( (lv_targetName_5_0= RULE_STRING ) )
-            // InternalRoom.g:671:1: (lv_targetName_5_0= RULE_STRING )
+            // InternalRoom.g:731:1: ( (lv_targetName_5_0= RULE_STRING ) )
+            // InternalRoom.g:732:1: (lv_targetName_5_0= RULE_STRING )
             {
-            // InternalRoom.g:671:1: (lv_targetName_5_0= RULE_STRING )
-            // InternalRoom.g:672:3: lv_targetName_5_0= RULE_STRING
+            // InternalRoom.g:732:1: (lv_targetName_5_0= RULE_STRING )
+            // InternalRoom.g:733:3: lv_targetName_5_0= RULE_STRING
             {
             lv_targetName_5_0=(Token)match(input,RULE_STRING,FOLLOW_13); 
 
@@ -1730,26 +1887,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:688:2: (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )?
-            int alt9=2;
-            int LA9_0 = input.LA(1);
+            // InternalRoom.g:749:2: (otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')' )?
+            int alt10=2;
+            int LA10_0 = input.LA(1);
 
-            if ( (LA9_0==20) ) {
-                alt9=1;
+            if ( (LA10_0==20) ) {
+                alt10=1;
             }
-            switch (alt9) {
+            switch (alt10) {
                 case 1 :
-                    // InternalRoom.g:688:4: otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')'
+                    // InternalRoom.g:749:4: otherlv_6= '(' ( (lv_castName_7_0= ruleFQN ) ) otherlv_8= ')'
                     {
                     otherlv_6=(Token)match(input,20,FOLLOW_3); 
 
                         	newLeafNode(otherlv_6, grammarAccess.getPrimitiveTypeAccess().getLeftParenthesisKeyword_6_0());
                         
-                    // InternalRoom.g:692:1: ( (lv_castName_7_0= ruleFQN ) )
-                    // InternalRoom.g:693:1: (lv_castName_7_0= ruleFQN )
+                    // InternalRoom.g:753:1: ( (lv_castName_7_0= ruleFQN ) )
+                    // InternalRoom.g:754:1: (lv_castName_7_0= ruleFQN )
                     {
-                    // InternalRoom.g:693:1: (lv_castName_7_0= ruleFQN )
-                    // InternalRoom.g:694:3: lv_castName_7_0= ruleFQN
+                    // InternalRoom.g:754:1: (lv_castName_7_0= ruleFQN )
+                    // InternalRoom.g:755:3: lv_castName_7_0= ruleFQN
                     {
                      
                     	        newCompositeNode(grammarAccess.getPrimitiveTypeAccess().getCastNameFQNParserRuleCall_6_1_0()); 
@@ -1790,11 +1947,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_9, grammarAccess.getPrimitiveTypeAccess().getDefaultKeyword_7());
                 
-            // InternalRoom.g:718:1: ( (lv_defaultValueLiteral_10_0= RULE_STRING ) )
-            // InternalRoom.g:719:1: (lv_defaultValueLiteral_10_0= RULE_STRING )
+            // InternalRoom.g:779:1: ( (lv_defaultValueLiteral_10_0= RULE_STRING ) )
+            // InternalRoom.g:780:1: (lv_defaultValueLiteral_10_0= RULE_STRING )
             {
-            // InternalRoom.g:719:1: (lv_defaultValueLiteral_10_0= RULE_STRING )
-            // InternalRoom.g:720:3: lv_defaultValueLiteral_10_0= RULE_STRING
+            // InternalRoom.g:780:1: (lv_defaultValueLiteral_10_0= RULE_STRING )
+            // InternalRoom.g:781:3: lv_defaultValueLiteral_10_0= RULE_STRING
             {
             lv_defaultValueLiteral_10_0=(Token)match(input,RULE_STRING,FOLLOW_16); 
 
@@ -1816,19 +1973,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:736:2: ( (lv_docu_11_0= ruleDocumentation ) )?
-            int alt10=2;
-            int LA10_0 = input.LA(1);
+            // InternalRoom.g:797:2: ( (lv_docu_11_0= ruleDocumentation ) )?
+            int alt11=2;
+            int LA11_0 = input.LA(1);
 
-            if ( (LA10_0==34) ) {
-                alt10=1;
+            if ( (LA11_0==34) ) {
+                alt11=1;
             }
-            switch (alt10) {
+            switch (alt11) {
                 case 1 :
-                    // InternalRoom.g:737:1: (lv_docu_11_0= ruleDocumentation )
+                    // InternalRoom.g:798:1: (lv_docu_11_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:737:1: (lv_docu_11_0= ruleDocumentation )
-                    // InternalRoom.g:738:3: lv_docu_11_0= ruleDocumentation
+                    // InternalRoom.g:798:1: (lv_docu_11_0= ruleDocumentation )
+                    // InternalRoom.g:799:3: lv_docu_11_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getPrimitiveTypeAccess().getDocuDocumentationParserRuleCall_9_0()); 
@@ -1879,7 +2036,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEnumerationType"
-    // InternalRoom.g:762:1: entryRuleEnumerationType returns [EObject current=null] : iv_ruleEnumerationType= ruleEnumerationType EOF ;
+    // InternalRoom.g:823:1: entryRuleEnumerationType returns [EObject current=null] : iv_ruleEnumerationType= ruleEnumerationType EOF ;
     public final EObject entryRuleEnumerationType() throws RecognitionException {
         EObject current = null;
 
@@ -1887,8 +2044,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:763:2: (iv_ruleEnumerationType= ruleEnumerationType EOF )
-            // InternalRoom.g:764:2: iv_ruleEnumerationType= ruleEnumerationType EOF
+            // InternalRoom.g:824:2: (iv_ruleEnumerationType= ruleEnumerationType EOF )
+            // InternalRoom.g:825:2: iv_ruleEnumerationType= ruleEnumerationType EOF
             {
              newCompositeNode(grammarAccess.getEnumerationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -1915,7 +2072,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleEnumerationType"
-    // InternalRoom.g:771:1: ruleEnumerationType returns [EObject current=null] : (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' ) ;
+    // InternalRoom.g:832:1: ruleEnumerationType returns [EObject current=null] : (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' ) ;
     public final EObject ruleEnumerationType() throws RecognitionException {
         EObject current = null;
 
@@ -1935,21 +2092,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:774:28: ( (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' ) )
-            // InternalRoom.g:775:1: (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' )
+            // InternalRoom.g:835:28: ( (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' ) )
+            // InternalRoom.g:836:1: (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' )
             {
-            // InternalRoom.g:775:1: (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' )
-            // InternalRoom.g:775:3: otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}'
+            // InternalRoom.g:836:1: (otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}' )
+            // InternalRoom.g:836:3: otherlv_0= 'Enumeration' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'of' ( ( ruleFQN ) ) )? otherlv_5= '{' ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )? otherlv_9= '}'
             {
             otherlv_0=(Token)match(input,23,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getEnumerationTypeAccess().getEnumerationKeyword_0());
                 
-            // InternalRoom.g:779:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:780:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:840:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:841:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:780:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:781:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:841:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:842:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_17); 
 
@@ -1971,19 +2128,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:797:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt11=2;
-            int LA11_0 = input.LA(1);
+            // InternalRoom.g:858:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt12=2;
+            int LA12_0 = input.LA(1);
 
-            if ( (LA11_0==34) ) {
-                alt11=1;
+            if ( (LA12_0==34) ) {
+                alt12=1;
             }
-            switch (alt11) {
+            switch (alt12) {
                 case 1 :
-                    // InternalRoom.g:798:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:859:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:798:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:799:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:859:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:860:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getEnumerationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -2013,26 +2170,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:815:3: (otherlv_3= 'of' ( ( ruleFQN ) ) )?
-            int alt12=2;
-            int LA12_0 = input.LA(1);
+            // InternalRoom.g:876:3: (otherlv_3= 'of' ( ( ruleFQN ) ) )?
+            int alt13=2;
+            int LA13_0 = input.LA(1);
 
-            if ( (LA12_0==24) ) {
-                alt12=1;
+            if ( (LA13_0==24) ) {
+                alt13=1;
             }
-            switch (alt12) {
+            switch (alt13) {
                 case 1 :
-                    // InternalRoom.g:815:5: otherlv_3= 'of' ( ( ruleFQN ) )
+                    // InternalRoom.g:876:5: otherlv_3= 'of' ( ( ruleFQN ) )
                     {
                     otherlv_3=(Token)match(input,24,FOLLOW_3); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getEnumerationTypeAccess().getOfKeyword_3_0());
                         
-                    // InternalRoom.g:819:1: ( ( ruleFQN ) )
-                    // InternalRoom.g:820:1: ( ruleFQN )
+                    // InternalRoom.g:880:1: ( ( ruleFQN ) )
+                    // InternalRoom.g:881:1: ( ruleFQN )
                     {
-                    // InternalRoom.g:820:1: ( ruleFQN )
-                    // InternalRoom.g:821:3: ruleFQN
+                    // InternalRoom.g:881:1: ( ruleFQN )
+                    // InternalRoom.g:882:3: ruleFQN
                     {
 
                     			if (current==null) {
@@ -2066,22 +2223,22 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_5, grammarAccess.getEnumerationTypeAccess().getLeftCurlyBracketKeyword_4());
                 
-            // InternalRoom.g:838:1: ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )?
-            int alt14=2;
-            int LA14_0 = input.LA(1);
+            // InternalRoom.g:899:1: ( ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )* )?
+            int alt15=2;
+            int LA15_0 = input.LA(1);
 
-            if ( (LA14_0==RULE_ID) ) {
-                alt14=1;
+            if ( (LA15_0==RULE_ID) ) {
+                alt15=1;
             }
-            switch (alt14) {
+            switch (alt15) {
                 case 1 :
-                    // InternalRoom.g:838:2: ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )*
+                    // InternalRoom.g:899:2: ( (lv_literals_6_0= ruleEnumLiteral ) ) (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )*
                     {
-                    // InternalRoom.g:838:2: ( (lv_literals_6_0= ruleEnumLiteral ) )
-                    // InternalRoom.g:839:1: (lv_literals_6_0= ruleEnumLiteral )
+                    // InternalRoom.g:899:2: ( (lv_literals_6_0= ruleEnumLiteral ) )
+                    // InternalRoom.g:900:1: (lv_literals_6_0= ruleEnumLiteral )
                     {
-                    // InternalRoom.g:839:1: (lv_literals_6_0= ruleEnumLiteral )
-                    // InternalRoom.g:840:3: lv_literals_6_0= ruleEnumLiteral
+                    // InternalRoom.g:900:1: (lv_literals_6_0= ruleEnumLiteral )
+                    // InternalRoom.g:901:3: lv_literals_6_0= ruleEnumLiteral
                     {
                      
                     	        newCompositeNode(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_0_0()); 
@@ -2108,30 +2265,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:856:2: (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )*
-                    loop13:
+                    // InternalRoom.g:917:2: (otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) ) )*
+                    loop14:
                     do {
-                        int alt13=2;
-                        int LA13_0 = input.LA(1);
+                        int alt14=2;
+                        int LA14_0 = input.LA(1);
 
-                        if ( (LA13_0==25) ) {
-                            alt13=1;
+                        if ( (LA14_0==25) ) {
+                            alt14=1;
                         }
 
 
-                        switch (alt13) {
+                        switch (alt14) {
                     	case 1 :
-                    	    // InternalRoom.g:856:4: otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) )
+                    	    // InternalRoom.g:917:4: otherlv_7= ',' ( (lv_literals_8_0= ruleEnumLiteral ) )
                     	    {
                     	    otherlv_7=(Token)match(input,25,FOLLOW_3); 
 
                     	        	newLeafNode(otherlv_7, grammarAccess.getEnumerationTypeAccess().getCommaKeyword_5_1_0());
                     	        
-                    	    // InternalRoom.g:860:1: ( (lv_literals_8_0= ruleEnumLiteral ) )
-                    	    // InternalRoom.g:861:1: (lv_literals_8_0= ruleEnumLiteral )
+                    	    // InternalRoom.g:921:1: ( (lv_literals_8_0= ruleEnumLiteral ) )
+                    	    // InternalRoom.g:922:1: (lv_literals_8_0= ruleEnumLiteral )
                     	    {
-                    	    // InternalRoom.g:861:1: (lv_literals_8_0= ruleEnumLiteral )
-                    	    // InternalRoom.g:862:3: lv_literals_8_0= ruleEnumLiteral
+                    	    // InternalRoom.g:922:1: (lv_literals_8_0= ruleEnumLiteral )
+                    	    // InternalRoom.g:923:3: lv_literals_8_0= ruleEnumLiteral
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_1_1_0()); 
@@ -2163,7 +2320,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop13;
+                    	    break loop14;
                         }
                     } while (true);
 
@@ -2198,7 +2355,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEnumLiteral"
-    // InternalRoom.g:890:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ;
+    // InternalRoom.g:951:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ;
     public final EObject entryRuleEnumLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -2206,8 +2363,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:891:2: (iv_ruleEnumLiteral= ruleEnumLiteral EOF )
-            // InternalRoom.g:892:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF
+            // InternalRoom.g:952:2: (iv_ruleEnumLiteral= ruleEnumLiteral EOF )
+            // InternalRoom.g:953:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF
             {
              newCompositeNode(grammarAccess.getEnumLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -2234,7 +2391,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleEnumLiteral"
-    // InternalRoom.g:899:1: ruleEnumLiteral returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? ) ;
+    // InternalRoom.g:960:1: ruleEnumLiteral returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? ) ;
     public final EObject ruleEnumLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -2246,17 +2403,17 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:902:28: ( ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? ) )
-            // InternalRoom.g:903:1: ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? )
+            // InternalRoom.g:963:28: ( ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? ) )
+            // InternalRoom.g:964:1: ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? )
             {
-            // InternalRoom.g:903:1: ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? )
-            // InternalRoom.g:903:2: ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )?
+            // InternalRoom.g:964:1: ( ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )? )
+            // InternalRoom.g:964:2: ( (lv_name_0_0= RULE_ID ) ) (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )?
             {
-            // InternalRoom.g:903:2: ( (lv_name_0_0= RULE_ID ) )
-            // InternalRoom.g:904:1: (lv_name_0_0= RULE_ID )
+            // InternalRoom.g:964:2: ( (lv_name_0_0= RULE_ID ) )
+            // InternalRoom.g:965:1: (lv_name_0_0= RULE_ID )
             {
-            // InternalRoom.g:904:1: (lv_name_0_0= RULE_ID )
-            // InternalRoom.g:905:3: lv_name_0_0= RULE_ID
+            // InternalRoom.g:965:1: (lv_name_0_0= RULE_ID )
+            // InternalRoom.g:966:3: lv_name_0_0= RULE_ID
             {
             lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_21); 
 
@@ -2278,26 +2435,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:921:2: (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )?
-            int alt15=2;
-            int LA15_0 = input.LA(1);
+            // InternalRoom.g:982:2: (otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) ) )?
+            int alt16=2;
+            int LA16_0 = input.LA(1);
 
-            if ( (LA15_0==26) ) {
-                alt15=1;
+            if ( (LA16_0==26) ) {
+                alt16=1;
             }
-            switch (alt15) {
+            switch (alt16) {
                 case 1 :
-                    // InternalRoom.g:921:4: otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) )
+                    // InternalRoom.g:982:4: otherlv_1= '=' ( (lv_literal_2_0= ruleIntLiteral ) )
                     {
                     otherlv_1=(Token)match(input,26,FOLLOW_22); 
 
                         	newLeafNode(otherlv_1, grammarAccess.getEnumLiteralAccess().getEqualsSignKeyword_1_0());
                         
-                    // InternalRoom.g:925:1: ( (lv_literal_2_0= ruleIntLiteral ) )
-                    // InternalRoom.g:926:1: (lv_literal_2_0= ruleIntLiteral )
+                    // InternalRoom.g:986:1: ( (lv_literal_2_0= ruleIntLiteral ) )
+                    // InternalRoom.g:987:1: (lv_literal_2_0= ruleIntLiteral )
                     {
-                    // InternalRoom.g:926:1: (lv_literal_2_0= ruleIntLiteral )
-                    // InternalRoom.g:927:3: lv_literal_2_0= ruleIntLiteral
+                    // InternalRoom.g:987:1: (lv_literal_2_0= ruleIntLiteral )
+                    // InternalRoom.g:988:3: lv_literal_2_0= ruleIntLiteral
                     {
                      
                     	        newCompositeNode(grammarAccess.getEnumLiteralAccess().getLiteralIntLiteralParserRuleCall_1_1_0()); 
@@ -2351,7 +2508,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleExternalType"
-    // InternalRoom.g:951:1: entryRuleExternalType returns [EObject current=null] : iv_ruleExternalType= ruleExternalType EOF ;
+    // InternalRoom.g:1012:1: entryRuleExternalType returns [EObject current=null] : iv_ruleExternalType= ruleExternalType EOF ;
     public final EObject entryRuleExternalType() throws RecognitionException {
         EObject current = null;
 
@@ -2359,8 +2516,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:952:2: (iv_ruleExternalType= ruleExternalType EOF )
-            // InternalRoom.g:953:2: iv_ruleExternalType= ruleExternalType EOF
+            // InternalRoom.g:1013:2: (iv_ruleExternalType= ruleExternalType EOF )
+            // InternalRoom.g:1014:2: iv_ruleExternalType= ruleExternalType EOF
             {
              newCompositeNode(grammarAccess.getExternalTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -2387,7 +2544,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleExternalType"
-    // InternalRoom.g:960:1: ruleExternalType returns [EObject current=null] : (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:1021:1: ruleExternalType returns [EObject current=null] : (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? ) ;
     public final EObject ruleExternalType() throws RecognitionException {
         EObject current = null;
 
@@ -2403,21 +2560,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:963:28: ( (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:964:1: (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? )
+            // InternalRoom.g:1024:28: ( (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:1025:1: (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:964:1: (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? )
-            // InternalRoom.g:964:3: otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )?
+            // InternalRoom.g:1025:1: (otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )? )
+            // InternalRoom.g:1025:3: otherlv_0= 'ExternalType' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '->' ( (lv_targetName_3_0= RULE_STRING ) ) (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )? ( (lv_docu_6_0= ruleDocumentation ) )?
             {
             otherlv_0=(Token)match(input,27,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getExternalTypeAccess().getExternalTypeKeyword_0());
                 
-            // InternalRoom.g:968:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:969:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1029:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:1030:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:969:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:970:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:1030:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1031:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_11); 
 
@@ -2443,11 +2600,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getExternalTypeAccess().getHyphenMinusGreaterThanSignKeyword_2());
                 
-            // InternalRoom.g:990:1: ( (lv_targetName_3_0= RULE_STRING ) )
-            // InternalRoom.g:991:1: (lv_targetName_3_0= RULE_STRING )
+            // InternalRoom.g:1051:1: ( (lv_targetName_3_0= RULE_STRING ) )
+            // InternalRoom.g:1052:1: (lv_targetName_3_0= RULE_STRING )
             {
-            // InternalRoom.g:991:1: (lv_targetName_3_0= RULE_STRING )
-            // InternalRoom.g:992:3: lv_targetName_3_0= RULE_STRING
+            // InternalRoom.g:1052:1: (lv_targetName_3_0= RULE_STRING )
+            // InternalRoom.g:1053:3: lv_targetName_3_0= RULE_STRING
             {
             lv_targetName_3_0=(Token)match(input,RULE_STRING,FOLLOW_23); 
 
@@ -2469,26 +2626,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1008:2: (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )?
-            int alt16=2;
-            int LA16_0 = input.LA(1);
+            // InternalRoom.g:1069:2: (otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) ) )?
+            int alt17=2;
+            int LA17_0 = input.LA(1);
 
-            if ( (LA16_0==22) ) {
-                alt16=1;
+            if ( (LA17_0==22) ) {
+                alt17=1;
             }
-            switch (alt16) {
+            switch (alt17) {
                 case 1 :
-                    // InternalRoom.g:1008:4: otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) )
+                    // InternalRoom.g:1069:4: otherlv_4= 'default' ( (lv_defaultValueLiteral_5_0= RULE_STRING ) )
                     {
                     otherlv_4=(Token)match(input,22,FOLLOW_12); 
 
                         	newLeafNode(otherlv_4, grammarAccess.getExternalTypeAccess().getDefaultKeyword_4_0());
                         
-                    // InternalRoom.g:1012:1: ( (lv_defaultValueLiteral_5_0= RULE_STRING ) )
-                    // InternalRoom.g:1013:1: (lv_defaultValueLiteral_5_0= RULE_STRING )
+                    // InternalRoom.g:1073:1: ( (lv_defaultValueLiteral_5_0= RULE_STRING ) )
+                    // InternalRoom.g:1074:1: (lv_defaultValueLiteral_5_0= RULE_STRING )
                     {
-                    // InternalRoom.g:1013:1: (lv_defaultValueLiteral_5_0= RULE_STRING )
-                    // InternalRoom.g:1014:3: lv_defaultValueLiteral_5_0= RULE_STRING
+                    // InternalRoom.g:1074:1: (lv_defaultValueLiteral_5_0= RULE_STRING )
+                    // InternalRoom.g:1075:3: lv_defaultValueLiteral_5_0= RULE_STRING
                     {
                     lv_defaultValueLiteral_5_0=(Token)match(input,RULE_STRING,FOLLOW_16); 
 
@@ -2516,19 +2673,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1030:4: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt17=2;
-            int LA17_0 = input.LA(1);
+            // InternalRoom.g:1091:4: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt18=2;
+            int LA18_0 = input.LA(1);
 
-            if ( (LA17_0==34) ) {
-                alt17=1;
+            if ( (LA18_0==34) ) {
+                alt18=1;
             }
-            switch (alt17) {
+            switch (alt18) {
                 case 1 :
-                    // InternalRoom.g:1031:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:1092:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1031:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:1032:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:1092:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:1093:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getExternalTypeAccess().getDocuDocumentationParserRuleCall_5_0()); 
@@ -2579,7 +2736,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDataClass"
-    // InternalRoom.g:1056:1: entryRuleDataClass returns [EObject current=null] : iv_ruleDataClass= ruleDataClass EOF ;
+    // InternalRoom.g:1117:1: entryRuleDataClass returns [EObject current=null] : iv_ruleDataClass= ruleDataClass EOF ;
     public final EObject entryRuleDataClass() throws RecognitionException {
         EObject current = null;
 
@@ -2587,8 +2744,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1057:2: (iv_ruleDataClass= ruleDataClass EOF )
-            // InternalRoom.g:1058:2: iv_ruleDataClass= ruleDataClass EOF
+            // InternalRoom.g:1118:2: (iv_ruleDataClass= ruleDataClass EOF )
+            // InternalRoom.g:1119:2: iv_ruleDataClass= ruleDataClass EOF
             {
              newCompositeNode(grammarAccess.getDataClassRule()); 
             pushFollow(FOLLOW_1);
@@ -2615,7 +2772,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDataClass"
-    // InternalRoom.g:1065:1: ruleDataClass returns [EObject current=null] : (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' ) ;
+    // InternalRoom.g:1126:1: ruleDataClass returns [EObject current=null] : (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' ) ;
     public final EObject ruleDataClass() throws RecognitionException {
         EObject current = null;
 
@@ -2647,21 +2804,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1068:28: ( (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' ) )
-            // InternalRoom.g:1069:1: (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' )
+            // InternalRoom.g:1129:28: ( (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' ) )
+            // InternalRoom.g:1130:1: (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' )
             {
-            // InternalRoom.g:1069:1: (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' )
-            // InternalRoom.g:1069:3: otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}'
+            // InternalRoom.g:1130:1: (otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}' )
+            // InternalRoom.g:1130:3: otherlv_0= 'DataClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= 'extends' ( ( ruleFQN ) ) )? otherlv_5= '{' ( (lv_annotations_6_0= ruleAnnotation ) )* (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )? (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )? ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )* otherlv_16= '}'
             {
             otherlv_0=(Token)match(input,28,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getDataClassAccess().getDataClassKeyword_0());
                 
-            // InternalRoom.g:1073:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:1074:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1134:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:1135:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:1074:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:1075:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:1135:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1136:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -2683,19 +2840,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1091:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt18=2;
-            int LA18_0 = input.LA(1);
+            // InternalRoom.g:1152:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt19=2;
+            int LA19_0 = input.LA(1);
 
-            if ( (LA18_0==34) ) {
-                alt18=1;
+            if ( (LA19_0==34) ) {
+                alt19=1;
             }
-            switch (alt18) {
+            switch (alt19) {
                 case 1 :
-                    // InternalRoom.g:1092:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:1153:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1092:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:1093:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:1153:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:1154:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getDataClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -2725,26 +2882,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1109:3: (otherlv_3= 'extends' ( ( ruleFQN ) ) )?
-            int alt19=2;
-            int LA19_0 = input.LA(1);
+            // InternalRoom.g:1170:3: (otherlv_3= 'extends' ( ( ruleFQN ) ) )?
+            int alt20=2;
+            int LA20_0 = input.LA(1);
 
-            if ( (LA19_0==29) ) {
-                alt19=1;
+            if ( (LA20_0==29) ) {
+                alt20=1;
             }
-            switch (alt19) {
+            switch (alt20) {
                 case 1 :
-                    // InternalRoom.g:1109:5: otherlv_3= 'extends' ( ( ruleFQN ) )
+                    // InternalRoom.g:1170:5: otherlv_3= 'extends' ( ( ruleFQN ) )
                     {
                     otherlv_3=(Token)match(input,29,FOLLOW_3); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getDataClassAccess().getExtendsKeyword_3_0());
                         
-                    // InternalRoom.g:1113:1: ( ( ruleFQN ) )
-                    // InternalRoom.g:1114:1: ( ruleFQN )
+                    // InternalRoom.g:1174:1: ( ( ruleFQN ) )
+                    // InternalRoom.g:1175:1: ( ruleFQN )
                     {
-                    // InternalRoom.g:1114:1: ( ruleFQN )
-                    // InternalRoom.g:1115:3: ruleFQN
+                    // InternalRoom.g:1175:1: ( ruleFQN )
+                    // InternalRoom.g:1176:3: ruleFQN
                     {
 
                     			if (current==null) {
@@ -2778,23 +2935,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_5, grammarAccess.getDataClassAccess().getLeftCurlyBracketKeyword_4());
                 
-            // InternalRoom.g:1132:1: ( (lv_annotations_6_0= ruleAnnotation ) )*
-            loop20:
+            // InternalRoom.g:1193:1: ( (lv_annotations_6_0= ruleAnnotation ) )*
+            loop21:
             do {
-                int alt20=2;
-                int LA20_0 = input.LA(1);
+                int alt21=2;
+                int LA21_0 = input.LA(1);
 
-                if ( (LA20_0==108) ) {
-                    alt20=1;
+                if ( (LA21_0==108) ) {
+                    alt21=1;
                 }
 
 
-                switch (alt20) {
+                switch (alt21) {
             	case 1 :
-            	    // InternalRoom.g:1133:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:1194:1: (lv_annotations_6_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:1133:1: (lv_annotations_6_0= ruleAnnotation )
-            	    // InternalRoom.g:1134:3: lv_annotations_6_0= ruleAnnotation
+            	    // InternalRoom.g:1194:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:1195:3: lv_annotations_6_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getDataClassAccess().getAnnotationsAnnotationParserRuleCall_5_0()); 
@@ -2823,30 +2980,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop20;
+            	    break loop21;
                 }
             } while (true);
 
-            // InternalRoom.g:1150:3: (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )?
-            int alt21=2;
-            int LA21_0 = input.LA(1);
+            // InternalRoom.g:1211:3: (otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) ) )?
+            int alt22=2;
+            int LA22_0 = input.LA(1);
 
-            if ( (LA21_0==30) ) {
-                alt21=1;
+            if ( (LA22_0==30) ) {
+                alt22=1;
             }
-            switch (alt21) {
+            switch (alt22) {
                 case 1 :
-                    // InternalRoom.g:1150:5: otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) )
+                    // InternalRoom.g:1211:5: otherlv_7= 'usercode1' ( (lv_userCode1_8_0= ruleDetailCode ) )
                     {
                     otherlv_7=(Token)match(input,30,FOLLOW_27); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getDataClassAccess().getUsercode1Keyword_6_0());
                         
-                    // InternalRoom.g:1154:1: ( (lv_userCode1_8_0= ruleDetailCode ) )
-                    // InternalRoom.g:1155:1: (lv_userCode1_8_0= ruleDetailCode )
+                    // InternalRoom.g:1215:1: ( (lv_userCode1_8_0= ruleDetailCode ) )
+                    // InternalRoom.g:1216:1: (lv_userCode1_8_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:1155:1: (lv_userCode1_8_0= ruleDetailCode )
-                    // InternalRoom.g:1156:3: lv_userCode1_8_0= ruleDetailCode
+                    // InternalRoom.g:1216:1: (lv_userCode1_8_0= ruleDetailCode )
+                    // InternalRoom.g:1217:3: lv_userCode1_8_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getDataClassAccess().getUserCode1DetailCodeParserRuleCall_6_1_0()); 
@@ -2879,26 +3036,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1172:4: (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )?
-            int alt22=2;
-            int LA22_0 = input.LA(1);
+            // InternalRoom.g:1233:4: (otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) ) )?
+            int alt23=2;
+            int LA23_0 = input.LA(1);
 
-            if ( (LA22_0==31) ) {
-                alt22=1;
+            if ( (LA23_0==31) ) {
+                alt23=1;
             }
-            switch (alt22) {
+            switch (alt23) {
                 case 1 :
-                    // InternalRoom.g:1172:6: otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) )
+                    // InternalRoom.g:1233:6: otherlv_9= 'usercode2' ( (lv_userCode2_10_0= ruleDetailCode ) )
                     {
                     otherlv_9=(Token)match(input,31,FOLLOW_29); 
 
                         	newLeafNode(otherlv_9, grammarAccess.getDataClassAccess().getUsercode2Keyword_7_0());
                         
-                    // InternalRoom.g:1176:1: ( (lv_userCode2_10_0= ruleDetailCode ) )
-                    // InternalRoom.g:1177:1: (lv_userCode2_10_0= ruleDetailCode )
+                    // InternalRoom.g:1237:1: ( (lv_userCode2_10_0= ruleDetailCode ) )
+                    // InternalRoom.g:1238:1: (lv_userCode2_10_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:1177:1: (lv_userCode2_10_0= ruleDetailCode )
-                    // InternalRoom.g:1178:3: lv_userCode2_10_0= ruleDetailCode
+                    // InternalRoom.g:1238:1: (lv_userCode2_10_0= ruleDetailCode )
+                    // InternalRoom.g:1239:3: lv_userCode2_10_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getDataClassAccess().getUserCode2DetailCodeParserRuleCall_7_1_0()); 
@@ -2931,26 +3088,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1194:4: (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )?
-            int alt23=2;
-            int LA23_0 = input.LA(1);
+            // InternalRoom.g:1255:4: (otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) ) )?
+            int alt24=2;
+            int LA24_0 = input.LA(1);
 
-            if ( (LA23_0==32) ) {
-                alt23=1;
+            if ( (LA24_0==32) ) {
+                alt24=1;
             }
-            switch (alt23) {
+            switch (alt24) {
                 case 1 :
-                    // InternalRoom.g:1194:6: otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) )
+                    // InternalRoom.g:1255:6: otherlv_11= 'usercode3' ( (lv_userCode3_12_0= ruleDetailCode ) )
                     {
                     otherlv_11=(Token)match(input,32,FOLLOW_31); 
 
                         	newLeafNode(otherlv_11, grammarAccess.getDataClassAccess().getUsercode3Keyword_8_0());
                         
-                    // InternalRoom.g:1198:1: ( (lv_userCode3_12_0= ruleDetailCode ) )
-                    // InternalRoom.g:1199:1: (lv_userCode3_12_0= ruleDetailCode )
+                    // InternalRoom.g:1259:1: ( (lv_userCode3_12_0= ruleDetailCode ) )
+                    // InternalRoom.g:1260:1: (lv_userCode3_12_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:1199:1: (lv_userCode3_12_0= ruleDetailCode )
-                    // InternalRoom.g:1200:3: lv_userCode3_12_0= ruleDetailCode
+                    // InternalRoom.g:1260:1: (lv_userCode3_12_0= ruleDetailCode )
+                    // InternalRoom.g:1261:3: lv_userCode3_12_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getDataClassAccess().getUserCode3DetailCodeParserRuleCall_8_1_0()); 
@@ -2983,40 +3140,40 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1216:4: ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )*
-            loop24:
+            // InternalRoom.g:1277:4: ( ( (lv_operations_13_0= ruleStandardOperation ) ) | ( (lv_structors_14_0= ruleClassStructor ) ) | ( (lv_attributes_15_0= ruleAttribute ) ) )*
+            loop25:
             do {
-                int alt24=4;
+                int alt25=4;
                 switch ( input.LA(1) ) {
                 case 36:
                 case 37:
                     {
-                    alt24=1;
+                    alt25=1;
                     }
                     break;
                 case 40:
                 case 41:
                     {
-                    alt24=2;
+                    alt25=2;
                     }
                     break;
                 case 33:
                     {
-                    alt24=3;
+                    alt25=3;
                     }
                     break;
 
                 }
 
-                switch (alt24) {
+                switch (alt25) {
             	case 1 :
-            	    // InternalRoom.g:1216:5: ( (lv_operations_13_0= ruleStandardOperation ) )
+            	    // InternalRoom.g:1277:5: ( (lv_operations_13_0= ruleStandardOperation ) )
             	    {
-            	    // InternalRoom.g:1216:5: ( (lv_operations_13_0= ruleStandardOperation ) )
-            	    // InternalRoom.g:1217:1: (lv_operations_13_0= ruleStandardOperation )
+            	    // InternalRoom.g:1277:5: ( (lv_operations_13_0= ruleStandardOperation ) )
+            	    // InternalRoom.g:1278:1: (lv_operations_13_0= ruleStandardOperation )
             	    {
-            	    // InternalRoom.g:1217:1: (lv_operations_13_0= ruleStandardOperation )
-            	    // InternalRoom.g:1218:3: lv_operations_13_0= ruleStandardOperation
+            	    // InternalRoom.g:1278:1: (lv_operations_13_0= ruleStandardOperation )
+            	    // InternalRoom.g:1279:3: lv_operations_13_0= ruleStandardOperation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getDataClassAccess().getOperationsStandardOperationParserRuleCall_9_0_0()); 
@@ -3047,13 +3204,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:1235:6: ( (lv_structors_14_0= ruleClassStructor ) )
+            	    // InternalRoom.g:1296:6: ( (lv_structors_14_0= ruleClassStructor ) )
             	    {
-            	    // InternalRoom.g:1235:6: ( (lv_structors_14_0= ruleClassStructor ) )
-            	    // InternalRoom.g:1236:1: (lv_structors_14_0= ruleClassStructor )
+            	    // InternalRoom.g:1296:6: ( (lv_structors_14_0= ruleClassStructor ) )
+            	    // InternalRoom.g:1297:1: (lv_structors_14_0= ruleClassStructor )
             	    {
-            	    // InternalRoom.g:1236:1: (lv_structors_14_0= ruleClassStructor )
-            	    // InternalRoom.g:1237:3: lv_structors_14_0= ruleClassStructor
+            	    // InternalRoom.g:1297:1: (lv_structors_14_0= ruleClassStructor )
+            	    // InternalRoom.g:1298:3: lv_structors_14_0= ruleClassStructor
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getDataClassAccess().getStructorsClassStructorParserRuleCall_9_1_0()); 
@@ -3084,13 +3241,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:1254:6: ( (lv_attributes_15_0= ruleAttribute ) )
+            	    // InternalRoom.g:1315:6: ( (lv_attributes_15_0= ruleAttribute ) )
             	    {
-            	    // InternalRoom.g:1254:6: ( (lv_attributes_15_0= ruleAttribute ) )
-            	    // InternalRoom.g:1255:1: (lv_attributes_15_0= ruleAttribute )
+            	    // InternalRoom.g:1315:6: ( (lv_attributes_15_0= ruleAttribute ) )
+            	    // InternalRoom.g:1316:1: (lv_attributes_15_0= ruleAttribute )
             	    {
-            	    // InternalRoom.g:1255:1: (lv_attributes_15_0= ruleAttribute )
-            	    // InternalRoom.g:1256:3: lv_attributes_15_0= ruleAttribute
+            	    // InternalRoom.g:1316:1: (lv_attributes_15_0= ruleAttribute )
+            	    // InternalRoom.g:1317:3: lv_attributes_15_0= ruleAttribute
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getDataClassAccess().getAttributesAttributeParserRuleCall_9_2_0()); 
@@ -3122,7 +3279,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop24;
+            	    break loop25;
                 }
             } while (true);
 
@@ -3151,7 +3308,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAttribute"
-    // InternalRoom.g:1284:1: entryRuleAttribute returns [EObject current=null] : iv_ruleAttribute= ruleAttribute EOF ;
+    // InternalRoom.g:1345:1: entryRuleAttribute returns [EObject current=null] : iv_ruleAttribute= ruleAttribute EOF ;
     public final EObject entryRuleAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -3159,8 +3316,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1285:2: (iv_ruleAttribute= ruleAttribute EOF )
-            // InternalRoom.g:1286:2: iv_ruleAttribute= ruleAttribute EOF
+            // InternalRoom.g:1346:2: (iv_ruleAttribute= ruleAttribute EOF )
+            // InternalRoom.g:1347:2: iv_ruleAttribute= ruleAttribute EOF
             {
              newCompositeNode(grammarAccess.getAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -3187,7 +3344,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAttribute"
-    // InternalRoom.g:1293:1: ruleAttribute returns [EObject current=null] : (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:1354:1: ruleAttribute returns [EObject current=null] : (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? ) ;
     public final EObject ruleAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -3207,21 +3364,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1296:28: ( (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:1297:1: (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? )
+            // InternalRoom.g:1357:28: ( (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:1358:1: (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:1297:1: (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? )
-            // InternalRoom.g:1297:3: otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )?
+            // InternalRoom.g:1358:1: (otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )? )
+            // InternalRoom.g:1358:3: otherlv_0= 'Attribute' ( (lv_name_1_0= RULE_ID ) ) (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )? otherlv_5= ':' ( (lv_type_6_0= ruleRefableType ) )? (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )? ( (lv_docu_9_0= ruleDocumentation ) )?
             {
             otherlv_0=(Token)match(input,33,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getAttributeAccess().getAttributeKeyword_0());
                 
-            // InternalRoom.g:1301:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:1302:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1362:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:1363:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:1302:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:1303:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:1363:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1364:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_33); 
 
@@ -3243,26 +3400,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1319:2: (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )?
-            int alt25=2;
-            int LA25_0 = input.LA(1);
+            // InternalRoom.g:1380:2: (otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']' )?
+            int alt26=2;
+            int LA26_0 = input.LA(1);
 
-            if ( (LA25_0==34) ) {
-                alt25=1;
+            if ( (LA26_0==34) ) {
+                alt26=1;
             }
-            switch (alt25) {
+            switch (alt26) {
                 case 1 :
-                    // InternalRoom.g:1319:4: otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']'
+                    // InternalRoom.g:1380:4: otherlv_2= '[' ( (lv_size_3_0= RULE_INT ) ) otherlv_4= ']'
                     {
                     otherlv_2=(Token)match(input,34,FOLLOW_34); 
 
                         	newLeafNode(otherlv_2, grammarAccess.getAttributeAccess().getLeftSquareBracketKeyword_2_0());
                         
-                    // InternalRoom.g:1323:1: ( (lv_size_3_0= RULE_INT ) )
-                    // InternalRoom.g:1324:1: (lv_size_3_0= RULE_INT )
+                    // InternalRoom.g:1384:1: ( (lv_size_3_0= RULE_INT ) )
+                    // InternalRoom.g:1385:1: (lv_size_3_0= RULE_INT )
                     {
-                    // InternalRoom.g:1324:1: (lv_size_3_0= RULE_INT )
-                    // InternalRoom.g:1325:3: lv_size_3_0= RULE_INT
+                    // InternalRoom.g:1385:1: (lv_size_3_0= RULE_INT )
+                    // InternalRoom.g:1386:3: lv_size_3_0= RULE_INT
                     {
                     lv_size_3_0=(Token)match(input,RULE_INT,FOLLOW_35); 
 
@@ -3298,19 +3455,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_5, grammarAccess.getAttributeAccess().getColonKeyword_3());
                 
-            // InternalRoom.g:1349:1: ( (lv_type_6_0= ruleRefableType ) )?
-            int alt26=2;
-            int LA26_0 = input.LA(1);
+            // InternalRoom.g:1410:1: ( (lv_type_6_0= ruleRefableType ) )?
+            int alt27=2;
+            int LA27_0 = input.LA(1);
 
-            if ( (LA26_0==RULE_ID) ) {
-                alt26=1;
+            if ( (LA27_0==RULE_ID) ) {
+                alt27=1;
             }
-            switch (alt26) {
+            switch (alt27) {
                 case 1 :
-                    // InternalRoom.g:1350:1: (lv_type_6_0= ruleRefableType )
+                    // InternalRoom.g:1411:1: (lv_type_6_0= ruleRefableType )
                     {
-                    // InternalRoom.g:1350:1: (lv_type_6_0= ruleRefableType )
-                    // InternalRoom.g:1351:3: lv_type_6_0= ruleRefableType
+                    // InternalRoom.g:1411:1: (lv_type_6_0= ruleRefableType )
+                    // InternalRoom.g:1412:3: lv_type_6_0= ruleRefableType
                     {
                      
                     	        newCompositeNode(grammarAccess.getAttributeAccess().getTypeRefableTypeParserRuleCall_4_0()); 
@@ -3340,26 +3497,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1367:3: (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )?
-            int alt27=2;
-            int LA27_0 = input.LA(1);
+            // InternalRoom.g:1428:3: (otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) ) )?
+            int alt28=2;
+            int LA28_0 = input.LA(1);
 
-            if ( (LA27_0==26) ) {
-                alt27=1;
+            if ( (LA28_0==26) ) {
+                alt28=1;
             }
-            switch (alt27) {
+            switch (alt28) {
                 case 1 :
-                    // InternalRoom.g:1367:5: otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) )
+                    // InternalRoom.g:1428:5: otherlv_7= '=' ( (lv_defaultValueLiteral_8_0= RULE_STRING ) )
                     {
                     otherlv_7=(Token)match(input,26,FOLLOW_12); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getAttributeAccess().getEqualsSignKeyword_5_0());
                         
-                    // InternalRoom.g:1371:1: ( (lv_defaultValueLiteral_8_0= RULE_STRING ) )
-                    // InternalRoom.g:1372:1: (lv_defaultValueLiteral_8_0= RULE_STRING )
+                    // InternalRoom.g:1432:1: ( (lv_defaultValueLiteral_8_0= RULE_STRING ) )
+                    // InternalRoom.g:1433:1: (lv_defaultValueLiteral_8_0= RULE_STRING )
                     {
-                    // InternalRoom.g:1372:1: (lv_defaultValueLiteral_8_0= RULE_STRING )
-                    // InternalRoom.g:1373:3: lv_defaultValueLiteral_8_0= RULE_STRING
+                    // InternalRoom.g:1433:1: (lv_defaultValueLiteral_8_0= RULE_STRING )
+                    // InternalRoom.g:1434:3: lv_defaultValueLiteral_8_0= RULE_STRING
                     {
                     lv_defaultValueLiteral_8_0=(Token)match(input,RULE_STRING,FOLLOW_16); 
 
@@ -3387,19 +3544,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1389:4: ( (lv_docu_9_0= ruleDocumentation ) )?
-            int alt28=2;
-            int LA28_0 = input.LA(1);
+            // InternalRoom.g:1450:4: ( (lv_docu_9_0= ruleDocumentation ) )?
+            int alt29=2;
+            int LA29_0 = input.LA(1);
 
-            if ( (LA28_0==34) ) {
-                alt28=1;
+            if ( (LA29_0==34) ) {
+                alt29=1;
             }
-            switch (alt28) {
+            switch (alt29) {
                 case 1 :
-                    // InternalRoom.g:1390:1: (lv_docu_9_0= ruleDocumentation )
+                    // InternalRoom.g:1451:1: (lv_docu_9_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1390:1: (lv_docu_9_0= ruleDocumentation )
-                    // InternalRoom.g:1391:3: lv_docu_9_0= ruleDocumentation
+                    // InternalRoom.g:1451:1: (lv_docu_9_0= ruleDocumentation )
+                    // InternalRoom.g:1452:3: lv_docu_9_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getAttributeAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -3450,7 +3607,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStandardOperation"
-    // InternalRoom.g:1417:1: entryRuleStandardOperation returns [EObject current=null] : iv_ruleStandardOperation= ruleStandardOperation EOF ;
+    // InternalRoom.g:1478:1: entryRuleStandardOperation returns [EObject current=null] : iv_ruleStandardOperation= ruleStandardOperation EOF ;
     public final EObject entryRuleStandardOperation() throws RecognitionException {
         EObject current = null;
 
@@ -3458,8 +3615,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1418:2: (iv_ruleStandardOperation= ruleStandardOperation EOF )
-            // InternalRoom.g:1419:2: iv_ruleStandardOperation= ruleStandardOperation EOF
+            // InternalRoom.g:1479:2: (iv_ruleStandardOperation= ruleStandardOperation EOF )
+            // InternalRoom.g:1480:2: iv_ruleStandardOperation= ruleStandardOperation EOF
             {
              newCompositeNode(grammarAccess.getStandardOperationRule()); 
             pushFollow(FOLLOW_1);
@@ -3486,7 +3643,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStandardOperation"
-    // InternalRoom.g:1426:1: ruleStandardOperation returns [EObject current=null] : ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:1487:1: ruleStandardOperation returns [EObject current=null] : ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) ) ;
     public final EObject ruleStandardOperation() throws RecognitionException {
         EObject current = null;
 
@@ -3512,25 +3669,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1429:28: ( ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:1430:1: ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1490:28: ( ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:1491:1: ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:1430:1: ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) )
-            // InternalRoom.g:1430:2: ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) )
+            // InternalRoom.g:1491:1: ( ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1491:2: ( (lv_override_0_0= 'override' ) )? otherlv_1= 'Operation' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )? otherlv_7= ')' (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )? ( (lv_docu_11_0= ruleDocumentation ) )? ( (lv_detailCode_12_0= ruleDetailCode ) )
             {
-            // InternalRoom.g:1430:2: ( (lv_override_0_0= 'override' ) )?
-            int alt29=2;
-            int LA29_0 = input.LA(1);
+            // InternalRoom.g:1491:2: ( (lv_override_0_0= 'override' ) )?
+            int alt30=2;
+            int LA30_0 = input.LA(1);
 
-            if ( (LA29_0==36) ) {
-                alt29=1;
+            if ( (LA30_0==36) ) {
+                alt30=1;
             }
-            switch (alt29) {
+            switch (alt30) {
                 case 1 :
-                    // InternalRoom.g:1431:1: (lv_override_0_0= 'override' )
+                    // InternalRoom.g:1492:1: (lv_override_0_0= 'override' )
                     {
-                    // InternalRoom.g:1431:1: (lv_override_0_0= 'override' )
-                    // InternalRoom.g:1432:3: lv_override_0_0= 'override'
+                    // InternalRoom.g:1492:1: (lv_override_0_0= 'override' )
+                    // InternalRoom.g:1493:3: lv_override_0_0= 'override'
                     {
                     lv_override_0_0=(Token)match(input,36,FOLLOW_38); 
 
@@ -3555,11 +3712,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getStandardOperationAccess().getOperationKeyword_1());
                 
-            // InternalRoom.g:1449:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:1450:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:1510:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:1511:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:1450:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:1451:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:1511:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:1512:3: lv_name_2_0= RULE_ID
             {
             lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_39); 
 
@@ -3585,22 +3742,22 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_3, grammarAccess.getStandardOperationAccess().getLeftParenthesisKeyword_3());
                 
-            // InternalRoom.g:1471:1: ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )?
-            int alt31=2;
-            int LA31_0 = input.LA(1);
+            // InternalRoom.g:1532:1: ( ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )* )?
+            int alt32=2;
+            int LA32_0 = input.LA(1);
 
-            if ( (LA31_0==RULE_ID) ) {
-                alt31=1;
+            if ( (LA32_0==RULE_ID) ) {
+                alt32=1;
             }
-            switch (alt31) {
+            switch (alt32) {
                 case 1 :
-                    // InternalRoom.g:1471:2: ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )*
+                    // InternalRoom.g:1532:2: ( (lv_arguments_4_0= ruleVarDecl ) ) (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )*
                     {
-                    // InternalRoom.g:1471:2: ( (lv_arguments_4_0= ruleVarDecl ) )
-                    // InternalRoom.g:1472:1: (lv_arguments_4_0= ruleVarDecl )
+                    // InternalRoom.g:1532:2: ( (lv_arguments_4_0= ruleVarDecl ) )
+                    // InternalRoom.g:1533:1: (lv_arguments_4_0= ruleVarDecl )
                     {
-                    // InternalRoom.g:1472:1: (lv_arguments_4_0= ruleVarDecl )
-                    // InternalRoom.g:1473:3: lv_arguments_4_0= ruleVarDecl
+                    // InternalRoom.g:1533:1: (lv_arguments_4_0= ruleVarDecl )
+                    // InternalRoom.g:1534:3: lv_arguments_4_0= ruleVarDecl
                     {
                      
                     	        newCompositeNode(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_0_0()); 
@@ -3627,30 +3784,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:1489:2: (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )*
-                    loop30:
+                    // InternalRoom.g:1550:2: (otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) ) )*
+                    loop31:
                     do {
-                        int alt30=2;
-                        int LA30_0 = input.LA(1);
+                        int alt31=2;
+                        int LA31_0 = input.LA(1);
 
-                        if ( (LA30_0==25) ) {
-                            alt30=1;
+                        if ( (LA31_0==25) ) {
+                            alt31=1;
                         }
 
 
-                        switch (alt30) {
+                        switch (alt31) {
                     	case 1 :
-                    	    // InternalRoom.g:1489:4: otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) )
+                    	    // InternalRoom.g:1550:4: otherlv_5= ',' ( (lv_arguments_6_0= ruleVarDecl ) )
                     	    {
                     	    otherlv_5=(Token)match(input,25,FOLLOW_3); 
 
                     	        	newLeafNode(otherlv_5, grammarAccess.getStandardOperationAccess().getCommaKeyword_4_1_0());
                     	        
-                    	    // InternalRoom.g:1493:1: ( (lv_arguments_6_0= ruleVarDecl ) )
-                    	    // InternalRoom.g:1494:1: (lv_arguments_6_0= ruleVarDecl )
+                    	    // InternalRoom.g:1554:1: ( (lv_arguments_6_0= ruleVarDecl ) )
+                    	    // InternalRoom.g:1555:1: (lv_arguments_6_0= ruleVarDecl )
                     	    {
-                    	    // InternalRoom.g:1494:1: (lv_arguments_6_0= ruleVarDecl )
-                    	    // InternalRoom.g:1495:3: lv_arguments_6_0= ruleVarDecl
+                    	    // InternalRoom.g:1555:1: (lv_arguments_6_0= ruleVarDecl )
+                    	    // InternalRoom.g:1556:3: lv_arguments_6_0= ruleVarDecl
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_1_1_0()); 
@@ -3682,7 +3839,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop30;
+                    	    break loop31;
                         }
                     } while (true);
 
@@ -3696,40 +3853,40 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_7, grammarAccess.getStandardOperationAccess().getRightParenthesisKeyword_5());
                 
-            // InternalRoom.g:1515:1: (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )?
-            int alt33=2;
-            int LA33_0 = input.LA(1);
+            // InternalRoom.g:1576:1: (otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) ) )?
+            int alt34=2;
+            int LA34_0 = input.LA(1);
 
-            if ( (LA33_0==16) ) {
-                alt33=1;
+            if ( (LA34_0==16) ) {
+                alt34=1;
             }
-            switch (alt33) {
+            switch (alt34) {
                 case 1 :
-                    // InternalRoom.g:1515:3: otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) )
+                    // InternalRoom.g:1576:3: otherlv_8= ':' (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) )
                     {
                     otherlv_8=(Token)match(input,16,FOLLOW_43); 
 
                         	newLeafNode(otherlv_8, grammarAccess.getStandardOperationAccess().getColonKeyword_6_0());
                         
-                    // InternalRoom.g:1519:1: (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) )
-                    int alt32=2;
-                    int LA32_0 = input.LA(1);
+                    // InternalRoom.g:1580:1: (otherlv_9= 'void' | ( (lv_returnType_10_0= ruleRefableType ) ) )
+                    int alt33=2;
+                    int LA33_0 = input.LA(1);
 
-                    if ( (LA32_0==38) ) {
-                        alt32=1;
+                    if ( (LA33_0==38) ) {
+                        alt33=1;
                     }
-                    else if ( (LA32_0==RULE_ID) ) {
-                        alt32=2;
+                    else if ( (LA33_0==RULE_ID) ) {
+                        alt33=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 32, 0, input);
+                            new NoViableAltException("", 33, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt32) {
+                    switch (alt33) {
                         case 1 :
-                            // InternalRoom.g:1519:3: otherlv_9= 'void'
+                            // InternalRoom.g:1580:3: otherlv_9= 'void'
                             {
                             otherlv_9=(Token)match(input,38,FOLLOW_44); 
 
@@ -3739,13 +3896,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:1524:6: ( (lv_returnType_10_0= ruleRefableType ) )
+                            // InternalRoom.g:1585:6: ( (lv_returnType_10_0= ruleRefableType ) )
                             {
-                            // InternalRoom.g:1524:6: ( (lv_returnType_10_0= ruleRefableType ) )
-                            // InternalRoom.g:1525:1: (lv_returnType_10_0= ruleRefableType )
+                            // InternalRoom.g:1585:6: ( (lv_returnType_10_0= ruleRefableType ) )
+                            // InternalRoom.g:1586:1: (lv_returnType_10_0= ruleRefableType )
                             {
-                            // InternalRoom.g:1525:1: (lv_returnType_10_0= ruleRefableType )
-                            // InternalRoom.g:1526:3: lv_returnType_10_0= ruleRefableType
+                            // InternalRoom.g:1586:1: (lv_returnType_10_0= ruleRefableType )
+                            // InternalRoom.g:1587:3: lv_returnType_10_0= ruleRefableType
                             {
                              
                             	        newCompositeNode(grammarAccess.getStandardOperationAccess().getReturnTypeRefableTypeParserRuleCall_6_1_1_0()); 
@@ -3784,19 +3941,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1542:5: ( (lv_docu_11_0= ruleDocumentation ) )?
-            int alt34=2;
-            int LA34_0 = input.LA(1);
+            // InternalRoom.g:1603:5: ( (lv_docu_11_0= ruleDocumentation ) )?
+            int alt35=2;
+            int LA35_0 = input.LA(1);
 
-            if ( (LA34_0==34) ) {
-                alt34=1;
+            if ( (LA35_0==34) ) {
+                alt35=1;
             }
-            switch (alt34) {
+            switch (alt35) {
                 case 1 :
-                    // InternalRoom.g:1543:1: (lv_docu_11_0= ruleDocumentation )
+                    // InternalRoom.g:1604:1: (lv_docu_11_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1543:1: (lv_docu_11_0= ruleDocumentation )
-                    // InternalRoom.g:1544:3: lv_docu_11_0= ruleDocumentation
+                    // InternalRoom.g:1604:1: (lv_docu_11_0= ruleDocumentation )
+                    // InternalRoom.g:1605:3: lv_docu_11_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getStandardOperationAccess().getDocuDocumentationParserRuleCall_7_0()); 
@@ -3826,11 +3983,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1560:3: ( (lv_detailCode_12_0= ruleDetailCode ) )
-            // InternalRoom.g:1561:1: (lv_detailCode_12_0= ruleDetailCode )
+            // InternalRoom.g:1621:3: ( (lv_detailCode_12_0= ruleDetailCode ) )
+            // InternalRoom.g:1622:1: (lv_detailCode_12_0= ruleDetailCode )
             {
-            // InternalRoom.g:1561:1: (lv_detailCode_12_0= ruleDetailCode )
-            // InternalRoom.g:1562:3: lv_detailCode_12_0= ruleDetailCode
+            // InternalRoom.g:1622:1: (lv_detailCode_12_0= ruleDetailCode )
+            // InternalRoom.g:1623:3: lv_detailCode_12_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getStandardOperationAccess().getDetailCodeDetailCodeParserRuleCall_8_0()); 
@@ -3878,7 +4035,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRulePortOperation"
-    // InternalRoom.g:1586:1: entryRulePortOperation returns [EObject current=null] : iv_rulePortOperation= rulePortOperation EOF ;
+    // InternalRoom.g:1647:1: entryRulePortOperation returns [EObject current=null] : iv_rulePortOperation= rulePortOperation EOF ;
     public final EObject entryRulePortOperation() throws RecognitionException {
         EObject current = null;
 
@@ -3886,8 +4043,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1587:2: (iv_rulePortOperation= rulePortOperation EOF )
-            // InternalRoom.g:1588:2: iv_rulePortOperation= rulePortOperation EOF
+            // InternalRoom.g:1648:2: (iv_rulePortOperation= rulePortOperation EOF )
+            // InternalRoom.g:1649:2: iv_rulePortOperation= rulePortOperation EOF
             {
              newCompositeNode(grammarAccess.getPortOperationRule()); 
             pushFollow(FOLLOW_1);
@@ -3914,7 +4071,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "rulePortOperation"
-    // InternalRoom.g:1595:1: rulePortOperation returns [EObject current=null] : (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:1656:1: rulePortOperation returns [EObject current=null] : (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) ) ;
     public final EObject rulePortOperation() throws RecognitionException {
         EObject current = null;
 
@@ -3941,21 +4098,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1598:28: ( (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:1599:1: (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1659:28: ( (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:1660:1: (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:1599:1: (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) )
-            // InternalRoom.g:1599:3: otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) )
+            // InternalRoom.g:1660:1: (otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1660:3: otherlv_0= 'Operation' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '(' ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )? otherlv_6= ')' ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )? ( (lv_docu_12_0= ruleDocumentation ) )? ( (lv_detailCode_13_0= ruleDetailCode ) )
             {
             otherlv_0=(Token)match(input,37,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getPortOperationAccess().getOperationKeyword_0());
                 
-            // InternalRoom.g:1603:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:1604:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1664:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:1665:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:1604:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:1605:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:1665:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:1666:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_39); 
 
@@ -3981,22 +4138,22 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getPortOperationAccess().getLeftParenthesisKeyword_2());
                 
-            // InternalRoom.g:1625:1: ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )?
-            int alt36=2;
-            int LA36_0 = input.LA(1);
+            // InternalRoom.g:1686:1: ( ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )* )?
+            int alt37=2;
+            int LA37_0 = input.LA(1);
 
-            if ( (LA36_0==RULE_ID) ) {
-                alt36=1;
+            if ( (LA37_0==RULE_ID) ) {
+                alt37=1;
             }
-            switch (alt36) {
+            switch (alt37) {
                 case 1 :
-                    // InternalRoom.g:1625:2: ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )*
+                    // InternalRoom.g:1686:2: ( (lv_arguments_3_0= ruleVarDecl ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )*
                     {
-                    // InternalRoom.g:1625:2: ( (lv_arguments_3_0= ruleVarDecl ) )
-                    // InternalRoom.g:1626:1: (lv_arguments_3_0= ruleVarDecl )
+                    // InternalRoom.g:1686:2: ( (lv_arguments_3_0= ruleVarDecl ) )
+                    // InternalRoom.g:1687:1: (lv_arguments_3_0= ruleVarDecl )
                     {
-                    // InternalRoom.g:1626:1: (lv_arguments_3_0= ruleVarDecl )
-                    // InternalRoom.g:1627:3: lv_arguments_3_0= ruleVarDecl
+                    // InternalRoom.g:1687:1: (lv_arguments_3_0= ruleVarDecl )
+                    // InternalRoom.g:1688:3: lv_arguments_3_0= ruleVarDecl
                     {
                      
                     	        newCompositeNode(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_0_0()); 
@@ -4023,30 +4180,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:1643:2: (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )*
-                    loop35:
+                    // InternalRoom.g:1704:2: (otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) ) )*
+                    loop36:
                     do {
-                        int alt35=2;
-                        int LA35_0 = input.LA(1);
+                        int alt36=2;
+                        int LA36_0 = input.LA(1);
 
-                        if ( (LA35_0==25) ) {
-                            alt35=1;
+                        if ( (LA36_0==25) ) {
+                            alt36=1;
                         }
 
 
-                        switch (alt35) {
+                        switch (alt36) {
                     	case 1 :
-                    	    // InternalRoom.g:1643:4: otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) )
+                    	    // InternalRoom.g:1704:4: otherlv_4= ',' ( (lv_arguments_5_0= ruleVarDecl ) )
                     	    {
                     	    otherlv_4=(Token)match(input,25,FOLLOW_3); 
 
                     	        	newLeafNode(otherlv_4, grammarAccess.getPortOperationAccess().getCommaKeyword_3_1_0());
                     	        
-                    	    // InternalRoom.g:1647:1: ( (lv_arguments_5_0= ruleVarDecl ) )
-                    	    // InternalRoom.g:1648:1: (lv_arguments_5_0= ruleVarDecl )
+                    	    // InternalRoom.g:1708:1: ( (lv_arguments_5_0= ruleVarDecl ) )
+                    	    // InternalRoom.g:1709:1: (lv_arguments_5_0= ruleVarDecl )
                     	    {
-                    	    // InternalRoom.g:1648:1: (lv_arguments_5_0= ruleVarDecl )
-                    	    // InternalRoom.g:1649:3: lv_arguments_5_0= ruleVarDecl
+                    	    // InternalRoom.g:1709:1: (lv_arguments_5_0= ruleVarDecl )
+                    	    // InternalRoom.g:1710:3: lv_arguments_5_0= ruleVarDecl
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_1_1_0()); 
@@ -4078,7 +4235,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop35;
+                    	    break loop36;
                         }
                     } while (true);
 
@@ -4092,46 +4249,46 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_6, grammarAccess.getPortOperationAccess().getRightParenthesisKeyword_4());
                 
-            // InternalRoom.g:1669:1: ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )?
-            int alt38=3;
-            int LA38_0 = input.LA(1);
+            // InternalRoom.g:1730:1: ( (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) ) | (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) ) )?
+            int alt39=3;
+            int LA39_0 = input.LA(1);
 
-            if ( (LA38_0==16) ) {
-                alt38=1;
+            if ( (LA39_0==16) ) {
+                alt39=1;
             }
-            else if ( (LA38_0==39) ) {
-                alt38=2;
+            else if ( (LA39_0==39) ) {
+                alt39=2;
             }
-            switch (alt38) {
+            switch (alt39) {
                 case 1 :
-                    // InternalRoom.g:1669:2: (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) )
+                    // InternalRoom.g:1730:2: (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) )
                     {
-                    // InternalRoom.g:1669:2: (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) )
-                    // InternalRoom.g:1669:4: otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) )
+                    // InternalRoom.g:1730:2: (otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) ) )
+                    // InternalRoom.g:1730:4: otherlv_7= ':' (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) )
                     {
                     otherlv_7=(Token)match(input,16,FOLLOW_43); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0());
                         
-                    // InternalRoom.g:1673:1: (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) )
-                    int alt37=2;
-                    int LA37_0 = input.LA(1);
+                    // InternalRoom.g:1734:1: (otherlv_8= 'void' | ( (lv_returnType_9_0= ruleRefableType ) ) )
+                    int alt38=2;
+                    int LA38_0 = input.LA(1);
 
-                    if ( (LA37_0==38) ) {
-                        alt37=1;
+                    if ( (LA38_0==38) ) {
+                        alt38=1;
                     }
-                    else if ( (LA37_0==RULE_ID) ) {
-                        alt37=2;
+                    else if ( (LA38_0==RULE_ID) ) {
+                        alt38=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 37, 0, input);
+                            new NoViableAltException("", 38, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt37) {
+                    switch (alt38) {
                         case 1 :
-                            // InternalRoom.g:1673:3: otherlv_8= 'void'
+                            // InternalRoom.g:1734:3: otherlv_8= 'void'
                             {
                             otherlv_8=(Token)match(input,38,FOLLOW_44); 
 
@@ -4141,13 +4298,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:1678:6: ( (lv_returnType_9_0= ruleRefableType ) )
+                            // InternalRoom.g:1739:6: ( (lv_returnType_9_0= ruleRefableType ) )
                             {
-                            // InternalRoom.g:1678:6: ( (lv_returnType_9_0= ruleRefableType ) )
-                            // InternalRoom.g:1679:1: (lv_returnType_9_0= ruleRefableType )
+                            // InternalRoom.g:1739:6: ( (lv_returnType_9_0= ruleRefableType ) )
+                            // InternalRoom.g:1740:1: (lv_returnType_9_0= ruleRefableType )
                             {
-                            // InternalRoom.g:1679:1: (lv_returnType_9_0= ruleRefableType )
-                            // InternalRoom.g:1680:3: lv_returnType_9_0= ruleRefableType
+                            // InternalRoom.g:1740:1: (lv_returnType_9_0= ruleRefableType )
+                            // InternalRoom.g:1741:3: lv_returnType_9_0= ruleRefableType
                             {
                              
                             	        newCompositeNode(grammarAccess.getPortOperationAccess().getReturnTypeRefableTypeParserRuleCall_5_0_1_1_0()); 
@@ -4187,20 +4344,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:1697:6: (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) )
+                    // InternalRoom.g:1758:6: (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) )
                     {
-                    // InternalRoom.g:1697:6: (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) )
-                    // InternalRoom.g:1697:8: otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) )
+                    // InternalRoom.g:1758:6: (otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) ) )
+                    // InternalRoom.g:1758:8: otherlv_10= 'sends' ( (otherlv_11= RULE_ID ) )
                     {
                     otherlv_10=(Token)match(input,39,FOLLOW_3); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getPortOperationAccess().getSendsKeyword_5_1_0());
                         
-                    // InternalRoom.g:1701:1: ( (otherlv_11= RULE_ID ) )
-                    // InternalRoom.g:1702:1: (otherlv_11= RULE_ID )
+                    // InternalRoom.g:1762:1: ( (otherlv_11= RULE_ID ) )
+                    // InternalRoom.g:1763:1: (otherlv_11= RULE_ID )
                     {
-                    // InternalRoom.g:1702:1: (otherlv_11= RULE_ID )
-                    // InternalRoom.g:1703:3: otherlv_11= RULE_ID
+                    // InternalRoom.g:1763:1: (otherlv_11= RULE_ID )
+                    // InternalRoom.g:1764:3: otherlv_11= RULE_ID
                     {
 
                     			if (current==null) {
@@ -4226,19 +4383,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1714:5: ( (lv_docu_12_0= ruleDocumentation ) )?
-            int alt39=2;
-            int LA39_0 = input.LA(1);
+            // InternalRoom.g:1775:5: ( (lv_docu_12_0= ruleDocumentation ) )?
+            int alt40=2;
+            int LA40_0 = input.LA(1);
 
-            if ( (LA39_0==34) ) {
-                alt39=1;
+            if ( (LA40_0==34) ) {
+                alt40=1;
             }
-            switch (alt39) {
+            switch (alt40) {
                 case 1 :
-                    // InternalRoom.g:1715:1: (lv_docu_12_0= ruleDocumentation )
+                    // InternalRoom.g:1776:1: (lv_docu_12_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1715:1: (lv_docu_12_0= ruleDocumentation )
-                    // InternalRoom.g:1716:3: lv_docu_12_0= ruleDocumentation
+                    // InternalRoom.g:1776:1: (lv_docu_12_0= ruleDocumentation )
+                    // InternalRoom.g:1777:3: lv_docu_12_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getPortOperationAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -4268,11 +4425,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1732:3: ( (lv_detailCode_13_0= ruleDetailCode ) )
-            // InternalRoom.g:1733:1: (lv_detailCode_13_0= ruleDetailCode )
+            // InternalRoom.g:1793:3: ( (lv_detailCode_13_0= ruleDetailCode ) )
+            // InternalRoom.g:1794:1: (lv_detailCode_13_0= ruleDetailCode )
             {
-            // InternalRoom.g:1733:1: (lv_detailCode_13_0= ruleDetailCode )
-            // InternalRoom.g:1734:3: lv_detailCode_13_0= ruleDetailCode
+            // InternalRoom.g:1794:1: (lv_detailCode_13_0= ruleDetailCode )
+            // InternalRoom.g:1795:3: lv_detailCode_13_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getPortOperationAccess().getDetailCodeDetailCodeParserRuleCall_7_0()); 
@@ -4320,7 +4477,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleClassStructor"
-    // InternalRoom.g:1758:1: entryRuleClassStructor returns [EObject current=null] : iv_ruleClassStructor= ruleClassStructor EOF ;
+    // InternalRoom.g:1819:1: entryRuleClassStructor returns [EObject current=null] : iv_ruleClassStructor= ruleClassStructor EOF ;
     public final EObject entryRuleClassStructor() throws RecognitionException {
         EObject current = null;
 
@@ -4328,8 +4485,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1759:2: (iv_ruleClassStructor= ruleClassStructor EOF )
-            // InternalRoom.g:1760:2: iv_ruleClassStructor= ruleClassStructor EOF
+            // InternalRoom.g:1820:2: (iv_ruleClassStructor= ruleClassStructor EOF )
+            // InternalRoom.g:1821:2: iv_ruleClassStructor= ruleClassStructor EOF
             {
              newCompositeNode(grammarAccess.getClassStructorRule()); 
             pushFollow(FOLLOW_1);
@@ -4356,7 +4513,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleClassStructor"
-    // InternalRoom.g:1767:1: ruleClassStructor returns [EObject current=null] : ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:1828:1: ruleClassStructor returns [EObject current=null] : ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) ) ;
     public final EObject ruleClassStructor() throws RecognitionException {
         EObject current = null;
 
@@ -4368,37 +4525,37 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1770:28: ( ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:1771:1: ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1831:28: ( ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:1832:1: ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:1771:1: ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) )
-            // InternalRoom.g:1771:2: ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) )
+            // InternalRoom.g:1832:1: ( ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) ) )
+            // InternalRoom.g:1832:2: ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) ) ( (lv_detailCode_1_0= ruleDetailCode ) )
             {
-            // InternalRoom.g:1771:2: ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) )
-            // InternalRoom.g:1772:1: ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) )
+            // InternalRoom.g:1832:2: ( ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) ) )
+            // InternalRoom.g:1833:1: ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) )
             {
-            // InternalRoom.g:1772:1: ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) )
-            // InternalRoom.g:1773:1: (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' )
+            // InternalRoom.g:1833:1: ( (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' ) )
+            // InternalRoom.g:1834:1: (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' )
             {
-            // InternalRoom.g:1773:1: (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' )
-            int alt40=2;
-            int LA40_0 = input.LA(1);
+            // InternalRoom.g:1834:1: (lv_name_0_1= 'ctor' | lv_name_0_2= 'dtor' )
+            int alt41=2;
+            int LA41_0 = input.LA(1);
 
-            if ( (LA40_0==40) ) {
-                alt40=1;
+            if ( (LA41_0==40) ) {
+                alt41=1;
             }
-            else if ( (LA40_0==41) ) {
-                alt40=2;
+            else if ( (LA41_0==41) ) {
+                alt41=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 40, 0, input);
+                    new NoViableAltException("", 41, 0, input);
 
                 throw nvae;
             }
-            switch (alt40) {
+            switch (alt41) {
                 case 1 :
-                    // InternalRoom.g:1774:3: lv_name_0_1= 'ctor'
+                    // InternalRoom.g:1835:3: lv_name_0_1= 'ctor'
                     {
                     lv_name_0_1=(Token)match(input,40,FOLLOW_45); 
 
@@ -4414,7 +4571,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:1786:8: lv_name_0_2= 'dtor'
+                    // InternalRoom.g:1847:8: lv_name_0_2= 'dtor'
                     {
                     lv_name_0_2=(Token)match(input,41,FOLLOW_45); 
 
@@ -4438,11 +4595,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1801:2: ( (lv_detailCode_1_0= ruleDetailCode ) )
-            // InternalRoom.g:1802:1: (lv_detailCode_1_0= ruleDetailCode )
+            // InternalRoom.g:1862:2: ( (lv_detailCode_1_0= ruleDetailCode ) )
+            // InternalRoom.g:1863:1: (lv_detailCode_1_0= ruleDetailCode )
             {
-            // InternalRoom.g:1802:1: (lv_detailCode_1_0= ruleDetailCode )
-            // InternalRoom.g:1803:3: lv_detailCode_1_0= ruleDetailCode
+            // InternalRoom.g:1863:1: (lv_detailCode_1_0= ruleDetailCode )
+            // InternalRoom.g:1864:3: lv_detailCode_1_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getClassStructorAccess().getDetailCodeDetailCodeParserRuleCall_1_0()); 
@@ -4490,7 +4647,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGeneralProtocolClass"
-    // InternalRoom.g:1827:1: entryRuleGeneralProtocolClass returns [EObject current=null] : iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF ;
+    // InternalRoom.g:1888:1: entryRuleGeneralProtocolClass returns [EObject current=null] : iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF ;
     public final EObject entryRuleGeneralProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -4498,8 +4655,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1828:2: (iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF )
-            // InternalRoom.g:1829:2: iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF
+            // InternalRoom.g:1889:2: (iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF )
+            // InternalRoom.g:1890:2: iv_ruleGeneralProtocolClass= ruleGeneralProtocolClass EOF
             {
              newCompositeNode(grammarAccess.getGeneralProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -4526,7 +4683,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleGeneralProtocolClass"
-    // InternalRoom.g:1836:1: ruleGeneralProtocolClass returns [EObject current=null] : (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass ) ;
+    // InternalRoom.g:1897:1: ruleGeneralProtocolClass returns [EObject current=null] : (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass ) ;
     public final EObject ruleGeneralProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -4538,28 +4695,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1839:28: ( (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass ) )
-            // InternalRoom.g:1840:1: (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass )
+            // InternalRoom.g:1900:28: ( (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass ) )
+            // InternalRoom.g:1901:1: (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass )
             {
-            // InternalRoom.g:1840:1: (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass )
-            int alt41=2;
-            int LA41_0 = input.LA(1);
+            // InternalRoom.g:1901:1: (this_ProtocolClass_0= ruleProtocolClass | this_CompoundProtocolClass_1= ruleCompoundProtocolClass )
+            int alt42=2;
+            int LA42_0 = input.LA(1);
 
-            if ( (LA41_0==42||(LA41_0>=124 && LA41_0<=126)) ) {
-                alt41=1;
+            if ( (LA42_0==42||(LA42_0>=124 && LA42_0<=126)) ) {
+                alt42=1;
             }
-            else if ( (LA41_0==48) ) {
-                alt41=2;
+            else if ( (LA42_0==48) ) {
+                alt42=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 41, 0, input);
+                    new NoViableAltException("", 42, 0, input);
 
                 throw nvae;
             }
-            switch (alt41) {
+            switch (alt42) {
                 case 1 :
-                    // InternalRoom.g:1841:5: this_ProtocolClass_0= ruleProtocolClass
+                    // InternalRoom.g:1902:5: this_ProtocolClass_0= ruleProtocolClass
                     {
                      
                             newCompositeNode(grammarAccess.getGeneralProtocolClassAccess().getProtocolClassParserRuleCall_0()); 
@@ -4577,7 +4734,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:1851:5: this_CompoundProtocolClass_1= ruleCompoundProtocolClass
+                    // InternalRoom.g:1912:5: this_CompoundProtocolClass_1= ruleCompoundProtocolClass
                     {
                      
                             newCompositeNode(grammarAccess.getGeneralProtocolClassAccess().getCompoundProtocolClassParserRuleCall_1()); 
@@ -4615,7 +4772,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleProtocolClass"
-    // InternalRoom.g:1867:1: entryRuleProtocolClass returns [EObject current=null] : iv_ruleProtocolClass= ruleProtocolClass EOF ;
+    // InternalRoom.g:1928:1: entryRuleProtocolClass returns [EObject current=null] : iv_ruleProtocolClass= ruleProtocolClass EOF ;
     public final EObject entryRuleProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -4623,8 +4780,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:1868:2: (iv_ruleProtocolClass= ruleProtocolClass EOF )
-            // InternalRoom.g:1869:2: iv_ruleProtocolClass= ruleProtocolClass EOF
+            // InternalRoom.g:1929:2: (iv_ruleProtocolClass= ruleProtocolClass EOF )
+            // InternalRoom.g:1930:2: iv_ruleProtocolClass= ruleProtocolClass EOF
             {
              newCompositeNode(grammarAccess.getProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -4651,7 +4808,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleProtocolClass"
-    // InternalRoom.g:1876:1: ruleProtocolClass returns [EObject current=null] : ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' ) ;
+    // InternalRoom.g:1937:1: ruleProtocolClass returns [EObject current=null] : ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' ) ;
     public final EObject ruleProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -4699,25 +4856,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:1879:28: ( ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' ) )
-            // InternalRoom.g:1880:1: ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' )
+            // InternalRoom.g:1940:28: ( ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' ) )
+            // InternalRoom.g:1941:1: ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' )
             {
-            // InternalRoom.g:1880:1: ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' )
-            // InternalRoom.g:1880:2: ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}'
+            // InternalRoom.g:1941:1: ( ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}' )
+            // InternalRoom.g:1941:2: ( (lv_commType_0_0= ruleCommunicationType ) )? otherlv_1= 'ProtocolClass' ( (lv_name_2_0= RULE_ID ) ) ( (lv_docu_3_0= ruleDocumentation ) )? (otherlv_4= 'extends' ( ( ruleFQN ) ) )? otherlv_6= '{' ( (lv_annotations_7_0= ruleAnnotation ) )* (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )? (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )? (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )? (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )? (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )? (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )? (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )? ( (lv_semantics_28_0= ruleProtocolSemantics ) )? otherlv_29= '}'
             {
-            // InternalRoom.g:1880:2: ( (lv_commType_0_0= ruleCommunicationType ) )?
-            int alt42=2;
-            int LA42_0 = input.LA(1);
+            // InternalRoom.g:1941:2: ( (lv_commType_0_0= ruleCommunicationType ) )?
+            int alt43=2;
+            int LA43_0 = input.LA(1);
 
-            if ( ((LA42_0>=124 && LA42_0<=126)) ) {
-                alt42=1;
+            if ( ((LA43_0>=124 && LA43_0<=126)) ) {
+                alt43=1;
             }
-            switch (alt42) {
+            switch (alt43) {
                 case 1 :
-                    // InternalRoom.g:1881:1: (lv_commType_0_0= ruleCommunicationType )
+                    // InternalRoom.g:1942:1: (lv_commType_0_0= ruleCommunicationType )
                     {
-                    // InternalRoom.g:1881:1: (lv_commType_0_0= ruleCommunicationType )
-                    // InternalRoom.g:1882:3: lv_commType_0_0= ruleCommunicationType
+                    // InternalRoom.g:1942:1: (lv_commType_0_0= ruleCommunicationType )
+                    // InternalRoom.g:1943:3: lv_commType_0_0= ruleCommunicationType
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getCommTypeCommunicationTypeEnumRuleCall_0_0()); 
@@ -4751,11 +4908,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getProtocolClassAccess().getProtocolClassKeyword_1());
                 
-            // InternalRoom.g:1902:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:1903:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:1963:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:1964:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:1903:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:1904:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:1964:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:1965:3: lv_name_2_0= RULE_ID
             {
             lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -4777,19 +4934,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1920:2: ( (lv_docu_3_0= ruleDocumentation ) )?
-            int alt43=2;
-            int LA43_0 = input.LA(1);
+            // InternalRoom.g:1981:2: ( (lv_docu_3_0= ruleDocumentation ) )?
+            int alt44=2;
+            int LA44_0 = input.LA(1);
 
-            if ( (LA43_0==34) ) {
-                alt43=1;
+            if ( (LA44_0==34) ) {
+                alt44=1;
             }
-            switch (alt43) {
+            switch (alt44) {
                 case 1 :
-                    // InternalRoom.g:1921:1: (lv_docu_3_0= ruleDocumentation )
+                    // InternalRoom.g:1982:1: (lv_docu_3_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:1921:1: (lv_docu_3_0= ruleDocumentation )
-                    // InternalRoom.g:1922:3: lv_docu_3_0= ruleDocumentation
+                    // InternalRoom.g:1982:1: (lv_docu_3_0= ruleDocumentation )
+                    // InternalRoom.g:1983:3: lv_docu_3_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
@@ -4819,26 +4976,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:1938:3: (otherlv_4= 'extends' ( ( ruleFQN ) ) )?
-            int alt44=2;
-            int LA44_0 = input.LA(1);
+            // InternalRoom.g:1999:3: (otherlv_4= 'extends' ( ( ruleFQN ) ) )?
+            int alt45=2;
+            int LA45_0 = input.LA(1);
 
-            if ( (LA44_0==29) ) {
-                alt44=1;
+            if ( (LA45_0==29) ) {
+                alt45=1;
             }
-            switch (alt44) {
+            switch (alt45) {
                 case 1 :
-                    // InternalRoom.g:1938:5: otherlv_4= 'extends' ( ( ruleFQN ) )
+                    // InternalRoom.g:1999:5: otherlv_4= 'extends' ( ( ruleFQN ) )
                     {
                     otherlv_4=(Token)match(input,29,FOLLOW_3); 
 
                         	newLeafNode(otherlv_4, grammarAccess.getProtocolClassAccess().getExtendsKeyword_4_0());
                         
-                    // InternalRoom.g:1942:1: ( ( ruleFQN ) )
-                    // InternalRoom.g:1943:1: ( ruleFQN )
+                    // InternalRoom.g:2003:1: ( ( ruleFQN ) )
+                    // InternalRoom.g:2004:1: ( ruleFQN )
                     {
-                    // InternalRoom.g:1943:1: ( ruleFQN )
-                    // InternalRoom.g:1944:3: ruleFQN
+                    // InternalRoom.g:2004:1: ( ruleFQN )
+                    // InternalRoom.g:2005:3: ruleFQN
                     {
 
                     			if (current==null) {
@@ -4872,23 +5029,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_6, grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_5());
                 
-            // InternalRoom.g:1961:1: ( (lv_annotations_7_0= ruleAnnotation ) )*
-            loop45:
+            // InternalRoom.g:2022:1: ( (lv_annotations_7_0= ruleAnnotation ) )*
+            loop46:
             do {
-                int alt45=2;
-                int LA45_0 = input.LA(1);
+                int alt46=2;
+                int LA46_0 = input.LA(1);
 
-                if ( (LA45_0==108) ) {
-                    alt45=1;
+                if ( (LA46_0==108) ) {
+                    alt46=1;
                 }
 
 
-                switch (alt45) {
+                switch (alt46) {
             	case 1 :
-            	    // InternalRoom.g:1962:1: (lv_annotations_7_0= ruleAnnotation )
+            	    // InternalRoom.g:2023:1: (lv_annotations_7_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:1962:1: (lv_annotations_7_0= ruleAnnotation )
-            	    // InternalRoom.g:1963:3: lv_annotations_7_0= ruleAnnotation
+            	    // InternalRoom.g:2023:1: (lv_annotations_7_0= ruleAnnotation )
+            	    // InternalRoom.g:2024:3: lv_annotations_7_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
@@ -4917,30 +5074,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop45;
+            	    break loop46;
                 }
             } while (true);
 
-            // InternalRoom.g:1979:3: (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )?
-            int alt46=2;
-            int LA46_0 = input.LA(1);
+            // InternalRoom.g:2040:3: (otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) ) )?
+            int alt47=2;
+            int LA47_0 = input.LA(1);
 
-            if ( (LA46_0==30) ) {
-                alt46=1;
+            if ( (LA47_0==30) ) {
+                alt47=1;
             }
-            switch (alt46) {
+            switch (alt47) {
                 case 1 :
-                    // InternalRoom.g:1979:5: otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) )
+                    // InternalRoom.g:2040:5: otherlv_8= 'usercode1' ( (lv_userCode1_9_0= ruleDetailCode ) )
                     {
                     otherlv_8=(Token)match(input,30,FOLLOW_49); 
 
                         	newLeafNode(otherlv_8, grammarAccess.getProtocolClassAccess().getUsercode1Keyword_7_0());
                         
-                    // InternalRoom.g:1983:1: ( (lv_userCode1_9_0= ruleDetailCode ) )
-                    // InternalRoom.g:1984:1: (lv_userCode1_9_0= ruleDetailCode )
+                    // InternalRoom.g:2044:1: ( (lv_userCode1_9_0= ruleDetailCode ) )
+                    // InternalRoom.g:2045:1: (lv_userCode1_9_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:1984:1: (lv_userCode1_9_0= ruleDetailCode )
-                    // InternalRoom.g:1985:3: lv_userCode1_9_0= ruleDetailCode
+                    // InternalRoom.g:2045:1: (lv_userCode1_9_0= ruleDetailCode )
+                    // InternalRoom.g:2046:3: lv_userCode1_9_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getUserCode1DetailCodeParserRuleCall_7_1_0()); 
@@ -4973,26 +5130,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2001:4: (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )?
-            int alt47=2;
-            int LA47_0 = input.LA(1);
+            // InternalRoom.g:2062:4: (otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) ) )?
+            int alt48=2;
+            int LA48_0 = input.LA(1);
 
-            if ( (LA47_0==31) ) {
-                alt47=1;
+            if ( (LA48_0==31) ) {
+                alt48=1;
             }
-            switch (alt47) {
+            switch (alt48) {
                 case 1 :
-                    // InternalRoom.g:2001:6: otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:2062:6: otherlv_10= 'usercode2' ( (lv_userCode2_11_0= ruleDetailCode ) )
                     {
                     otherlv_10=(Token)match(input,31,FOLLOW_51); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getProtocolClassAccess().getUsercode2Keyword_8_0());
                         
-                    // InternalRoom.g:2005:1: ( (lv_userCode2_11_0= ruleDetailCode ) )
-                    // InternalRoom.g:2006:1: (lv_userCode2_11_0= ruleDetailCode )
+                    // InternalRoom.g:2066:1: ( (lv_userCode2_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:2067:1: (lv_userCode2_11_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:2006:1: (lv_userCode2_11_0= ruleDetailCode )
-                    // InternalRoom.g:2007:3: lv_userCode2_11_0= ruleDetailCode
+                    // InternalRoom.g:2067:1: (lv_userCode2_11_0= ruleDetailCode )
+                    // InternalRoom.g:2068:3: lv_userCode2_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getUserCode2DetailCodeParserRuleCall_8_1_0()); 
@@ -5025,26 +5182,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2023:4: (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )?
-            int alt48=2;
-            int LA48_0 = input.LA(1);
+            // InternalRoom.g:2084:4: (otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) ) )?
+            int alt49=2;
+            int LA49_0 = input.LA(1);
 
-            if ( (LA48_0==32) ) {
-                alt48=1;
+            if ( (LA49_0==32) ) {
+                alt49=1;
             }
-            switch (alt48) {
+            switch (alt49) {
                 case 1 :
-                    // InternalRoom.g:2023:6: otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) )
+                    // InternalRoom.g:2084:6: otherlv_12= 'usercode3' ( (lv_userCode3_13_0= ruleDetailCode ) )
                     {
                     otherlv_12=(Token)match(input,32,FOLLOW_53); 
 
                         	newLeafNode(otherlv_12, grammarAccess.getProtocolClassAccess().getUsercode3Keyword_9_0());
                         
-                    // InternalRoom.g:2027:1: ( (lv_userCode3_13_0= ruleDetailCode ) )
-                    // InternalRoom.g:2028:1: (lv_userCode3_13_0= ruleDetailCode )
+                    // InternalRoom.g:2088:1: ( (lv_userCode3_13_0= ruleDetailCode ) )
+                    // InternalRoom.g:2089:1: (lv_userCode3_13_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:2028:1: (lv_userCode3_13_0= ruleDetailCode )
-                    // InternalRoom.g:2029:3: lv_userCode3_13_0= ruleDetailCode
+                    // InternalRoom.g:2089:1: (lv_userCode3_13_0= ruleDetailCode )
+                    // InternalRoom.g:2090:3: lv_userCode3_13_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getUserCode3DetailCodeParserRuleCall_9_1_0()); 
@@ -5077,16 +5234,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2045:4: (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )?
-            int alt50=2;
-            int LA50_0 = input.LA(1);
+            // InternalRoom.g:2106:4: (otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}' )?
+            int alt51=2;
+            int LA51_0 = input.LA(1);
 
-            if ( (LA50_0==43) ) {
-                alt50=1;
+            if ( (LA51_0==43) ) {
+                alt51=1;
             }
-            switch (alt50) {
+            switch (alt51) {
                 case 1 :
-                    // InternalRoom.g:2045:6: otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}'
+                    // InternalRoom.g:2106:6: otherlv_14= 'incoming' otherlv_15= '{' ( (lv_incomingMessages_16_0= ruleMessage ) )* otherlv_17= '}'
                     {
                     otherlv_14=(Token)match(input,43,FOLLOW_5); 
 
@@ -5096,23 +5253,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                         	newLeafNode(otherlv_15, grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1());
                         
-                    // InternalRoom.g:2053:1: ( (lv_incomingMessages_16_0= ruleMessage ) )*
-                    loop49:
+                    // InternalRoom.g:2114:1: ( (lv_incomingMessages_16_0= ruleMessage ) )*
+                    loop50:
                     do {
-                        int alt49=2;
-                        int LA49_0 = input.LA(1);
+                        int alt50=2;
+                        int LA50_0 = input.LA(1);
 
-                        if ( ((LA49_0>=50 && LA49_0<=51)) ) {
-                            alt49=1;
+                        if ( ((LA50_0>=50 && LA50_0<=51)) ) {
+                            alt50=1;
                         }
 
 
-                        switch (alt49) {
+                        switch (alt50) {
                     	case 1 :
-                    	    // InternalRoom.g:2054:1: (lv_incomingMessages_16_0= ruleMessage )
+                    	    // InternalRoom.g:2115:1: (lv_incomingMessages_16_0= ruleMessage )
                     	    {
-                    	    // InternalRoom.g:2054:1: (lv_incomingMessages_16_0= ruleMessage )
-                    	    // InternalRoom.g:2055:3: lv_incomingMessages_16_0= ruleMessage
+                    	    // InternalRoom.g:2115:1: (lv_incomingMessages_16_0= ruleMessage )
+                    	    // InternalRoom.g:2116:3: lv_incomingMessages_16_0= ruleMessage
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getProtocolClassAccess().getIncomingMessagesMessageParserRuleCall_10_2_0()); 
@@ -5141,7 +5298,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop49;
+                    	    break loop50;
                         }
                     } while (true);
 
@@ -5155,16 +5312,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2075:3: (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )?
-            int alt52=2;
-            int LA52_0 = input.LA(1);
+            // InternalRoom.g:2136:3: (otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}' )?
+            int alt53=2;
+            int LA53_0 = input.LA(1);
 
-            if ( (LA52_0==44) ) {
-                alt52=1;
+            if ( (LA53_0==44) ) {
+                alt53=1;
             }
-            switch (alt52) {
+            switch (alt53) {
                 case 1 :
-                    // InternalRoom.g:2075:5: otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}'
+                    // InternalRoom.g:2136:5: otherlv_18= 'outgoing' otherlv_19= '{' ( (lv_outgoingMessages_20_0= ruleMessage ) )* otherlv_21= '}'
                     {
                     otherlv_18=(Token)match(input,44,FOLLOW_5); 
 
@@ -5174,23 +5331,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                         	newLeafNode(otherlv_19, grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1());
                         
-                    // InternalRoom.g:2083:1: ( (lv_outgoingMessages_20_0= ruleMessage ) )*
-                    loop51:
+                    // InternalRoom.g:2144:1: ( (lv_outgoingMessages_20_0= ruleMessage ) )*
+                    loop52:
                     do {
-                        int alt51=2;
-                        int LA51_0 = input.LA(1);
+                        int alt52=2;
+                        int LA52_0 = input.LA(1);
 
-                        if ( ((LA51_0>=50 && LA51_0<=51)) ) {
-                            alt51=1;
+                        if ( ((LA52_0>=50 && LA52_0<=51)) ) {
+                            alt52=1;
                         }
 
 
-                        switch (alt51) {
+                        switch (alt52) {
                     	case 1 :
-                    	    // InternalRoom.g:2084:1: (lv_outgoingMessages_20_0= ruleMessage )
+                    	    // InternalRoom.g:2145:1: (lv_outgoingMessages_20_0= ruleMessage )
                     	    {
-                    	    // InternalRoom.g:2084:1: (lv_outgoingMessages_20_0= ruleMessage )
-                    	    // InternalRoom.g:2085:3: lv_outgoingMessages_20_0= ruleMessage
+                    	    // InternalRoom.g:2145:1: (lv_outgoingMessages_20_0= ruleMessage )
+                    	    // InternalRoom.g:2146:3: lv_outgoingMessages_20_0= ruleMessage
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getProtocolClassAccess().getOutgoingMessagesMessageParserRuleCall_11_2_0()); 
@@ -5219,7 +5376,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop51;
+                    	    break loop52;
                         }
                     } while (true);
 
@@ -5233,16 +5390,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2105:3: (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )?
-            int alt53=2;
-            int LA53_0 = input.LA(1);
+            // InternalRoom.g:2166:3: (otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) ) )?
+            int alt54=2;
+            int LA54_0 = input.LA(1);
 
-            if ( (LA53_0==45) ) {
-                alt53=1;
+            if ( (LA54_0==45) ) {
+                alt54=1;
             }
-            switch (alt53) {
+            switch (alt54) {
                 case 1 :
-                    // InternalRoom.g:2105:5: otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) )
+                    // InternalRoom.g:2166:5: otherlv_22= 'regular' otherlv_23= 'PortClass' ( (lv_regular_24_0= rulePortClass ) )
                     {
                     otherlv_22=(Token)match(input,45,FOLLOW_58); 
 
@@ -5252,11 +5409,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                         	newLeafNode(otherlv_23, grammarAccess.getProtocolClassAccess().getPortClassKeyword_12_1());
                         
-                    // InternalRoom.g:2113:1: ( (lv_regular_24_0= rulePortClass ) )
-                    // InternalRoom.g:2114:1: (lv_regular_24_0= rulePortClass )
+                    // InternalRoom.g:2174:1: ( (lv_regular_24_0= rulePortClass ) )
+                    // InternalRoom.g:2175:1: (lv_regular_24_0= rulePortClass )
                     {
-                    // InternalRoom.g:2114:1: (lv_regular_24_0= rulePortClass )
-                    // InternalRoom.g:2115:3: lv_regular_24_0= rulePortClass
+                    // InternalRoom.g:2175:1: (lv_regular_24_0= rulePortClass )
+                    // InternalRoom.g:2176:3: lv_regular_24_0= rulePortClass
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getRegularPortClassParserRuleCall_12_2_0()); 
@@ -5289,16 +5446,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2131:4: (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )?
-            int alt54=2;
-            int LA54_0 = input.LA(1);
+            // InternalRoom.g:2192:4: (otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) ) )?
+            int alt55=2;
+            int LA55_0 = input.LA(1);
 
-            if ( (LA54_0==47) ) {
-                alt54=1;
+            if ( (LA55_0==47) ) {
+                alt55=1;
             }
-            switch (alt54) {
+            switch (alt55) {
                 case 1 :
-                    // InternalRoom.g:2131:6: otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) )
+                    // InternalRoom.g:2192:6: otherlv_25= 'conjugated' otherlv_26= 'PortClass' ( (lv_conjugated_27_0= rulePortClass ) )
                     {
                     otherlv_25=(Token)match(input,47,FOLLOW_58); 
 
@@ -5308,11 +5465,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                         	newLeafNode(otherlv_26, grammarAccess.getProtocolClassAccess().getPortClassKeyword_13_1());
                         
-                    // InternalRoom.g:2139:1: ( (lv_conjugated_27_0= rulePortClass ) )
-                    // InternalRoom.g:2140:1: (lv_conjugated_27_0= rulePortClass )
+                    // InternalRoom.g:2200:1: ( (lv_conjugated_27_0= rulePortClass ) )
+                    // InternalRoom.g:2201:1: (lv_conjugated_27_0= rulePortClass )
                     {
-                    // InternalRoom.g:2140:1: (lv_conjugated_27_0= rulePortClass )
-                    // InternalRoom.g:2141:3: lv_conjugated_27_0= rulePortClass
+                    // InternalRoom.g:2201:1: (lv_conjugated_27_0= rulePortClass )
+                    // InternalRoom.g:2202:3: lv_conjugated_27_0= rulePortClass
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getConjugatedPortClassParserRuleCall_13_2_0()); 
@@ -5345,19 +5502,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2157:4: ( (lv_semantics_28_0= ruleProtocolSemantics ) )?
-            int alt55=2;
-            int LA55_0 = input.LA(1);
+            // InternalRoom.g:2218:4: ( (lv_semantics_28_0= ruleProtocolSemantics ) )?
+            int alt56=2;
+            int LA56_0 = input.LA(1);
 
-            if ( (LA55_0==105) ) {
-                alt55=1;
+            if ( (LA56_0==105) ) {
+                alt56=1;
             }
-            switch (alt55) {
+            switch (alt56) {
                 case 1 :
-                    // InternalRoom.g:2158:1: (lv_semantics_28_0= ruleProtocolSemantics )
+                    // InternalRoom.g:2219:1: (lv_semantics_28_0= ruleProtocolSemantics )
                     {
-                    // InternalRoom.g:2158:1: (lv_semantics_28_0= ruleProtocolSemantics )
-                    // InternalRoom.g:2159:3: lv_semantics_28_0= ruleProtocolSemantics
+                    // InternalRoom.g:2219:1: (lv_semantics_28_0= ruleProtocolSemantics )
+                    // InternalRoom.g:2220:3: lv_semantics_28_0= ruleProtocolSemantics
                     {
                      
                     	        newCompositeNode(grammarAccess.getProtocolClassAccess().getSemanticsProtocolSemanticsParserRuleCall_14_0()); 
@@ -5412,7 +5569,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleCompoundProtocolClass"
-    // InternalRoom.g:2187:1: entryRuleCompoundProtocolClass returns [EObject current=null] : iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF ;
+    // InternalRoom.g:2248:1: entryRuleCompoundProtocolClass returns [EObject current=null] : iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF ;
     public final EObject entryRuleCompoundProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -5420,8 +5577,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2188:2: (iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF )
-            // InternalRoom.g:2189:2: iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF
+            // InternalRoom.g:2249:2: (iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF )
+            // InternalRoom.g:2250:2: iv_ruleCompoundProtocolClass= ruleCompoundProtocolClass EOF
             {
              newCompositeNode(grammarAccess.getCompoundProtocolClassRule()); 
             pushFollow(FOLLOW_1);
@@ -5448,7 +5605,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleCompoundProtocolClass"
-    // InternalRoom.g:2196:1: ruleCompoundProtocolClass returns [EObject current=null] : (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' ) ;
+    // InternalRoom.g:2257:1: ruleCompoundProtocolClass returns [EObject current=null] : (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' ) ;
     public final EObject ruleCompoundProtocolClass() throws RecognitionException {
         EObject current = null;
 
@@ -5466,21 +5623,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2199:28: ( (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' ) )
-            // InternalRoom.g:2200:1: (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' )
+            // InternalRoom.g:2260:28: ( (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' ) )
+            // InternalRoom.g:2261:1: (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' )
             {
-            // InternalRoom.g:2200:1: (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' )
-            // InternalRoom.g:2200:3: otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}'
+            // InternalRoom.g:2261:1: (otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}' )
+            // InternalRoom.g:2261:3: otherlv_0= 'CompoundProtocolClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( (lv_subProtocols_5_0= ruleSubProtocol ) )* otherlv_6= '}'
             {
             otherlv_0=(Token)match(input,48,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getCompoundProtocolClassAccess().getCompoundProtocolClassKeyword_0());
                 
-            // InternalRoom.g:2204:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:2205:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:2265:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:2266:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:2205:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:2206:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:2266:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:2267:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_4); 
 
@@ -5502,19 +5659,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2222:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt56=2;
-            int LA56_0 = input.LA(1);
+            // InternalRoom.g:2283:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt57=2;
+            int LA57_0 = input.LA(1);
 
-            if ( (LA56_0==34) ) {
-                alt56=1;
+            if ( (LA57_0==34) ) {
+                alt57=1;
             }
-            switch (alt56) {
+            switch (alt57) {
                 case 1 :
-                    // InternalRoom.g:2223:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:2284:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:2223:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:2224:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:2284:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:2285:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getCompoundProtocolClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -5548,23 +5705,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_3, grammarAccess.getCompoundProtocolClassAccess().getLeftCurlyBracketKeyword_3());
                 
-            // InternalRoom.g:2244:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
-            loop57:
+            // InternalRoom.g:2305:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
+            loop58:
             do {
-                int alt57=2;
-                int LA57_0 = input.LA(1);
+                int alt58=2;
+                int LA58_0 = input.LA(1);
 
-                if ( (LA57_0==108) ) {
-                    alt57=1;
+                if ( (LA58_0==108) ) {
+                    alt58=1;
                 }
 
 
-                switch (alt57) {
+                switch (alt58) {
             	case 1 :
-            	    // InternalRoom.g:2245:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:2306:1: (lv_annotations_4_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:2245:1: (lv_annotations_4_0= ruleAnnotation )
-            	    // InternalRoom.g:2246:3: lv_annotations_4_0= ruleAnnotation
+            	    // InternalRoom.g:2306:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:2307:3: lv_annotations_4_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
@@ -5593,27 +5750,27 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop57;
+            	    break loop58;
                 }
             } while (true);
 
-            // InternalRoom.g:2262:3: ( (lv_subProtocols_5_0= ruleSubProtocol ) )*
-            loop58:
+            // InternalRoom.g:2323:3: ( (lv_subProtocols_5_0= ruleSubProtocol ) )*
+            loop59:
             do {
-                int alt58=2;
-                int LA58_0 = input.LA(1);
+                int alt59=2;
+                int LA59_0 = input.LA(1);
 
-                if ( (LA58_0==49) ) {
-                    alt58=1;
+                if ( (LA59_0==49) ) {
+                    alt59=1;
                 }
 
 
-                switch (alt58) {
+                switch (alt59) {
             	case 1 :
-            	    // InternalRoom.g:2263:1: (lv_subProtocols_5_0= ruleSubProtocol )
+            	    // InternalRoom.g:2324:1: (lv_subProtocols_5_0= ruleSubProtocol )
             	    {
-            	    // InternalRoom.g:2263:1: (lv_subProtocols_5_0= ruleSubProtocol )
-            	    // InternalRoom.g:2264:3: lv_subProtocols_5_0= ruleSubProtocol
+            	    // InternalRoom.g:2324:1: (lv_subProtocols_5_0= ruleSubProtocol )
+            	    // InternalRoom.g:2325:3: lv_subProtocols_5_0= ruleSubProtocol
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsSubProtocolParserRuleCall_5_0()); 
@@ -5642,7 +5799,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop58;
+            	    break loop59;
                 }
             } while (true);
 
@@ -5671,7 +5828,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubProtocol"
-    // InternalRoom.g:2292:1: entryRuleSubProtocol returns [EObject current=null] : iv_ruleSubProtocol= ruleSubProtocol EOF ;
+    // InternalRoom.g:2353:1: entryRuleSubProtocol returns [EObject current=null] : iv_ruleSubProtocol= ruleSubProtocol EOF ;
     public final EObject entryRuleSubProtocol() throws RecognitionException {
         EObject current = null;
 
@@ -5679,8 +5836,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2293:2: (iv_ruleSubProtocol= ruleSubProtocol EOF )
-            // InternalRoom.g:2294:2: iv_ruleSubProtocol= ruleSubProtocol EOF
+            // InternalRoom.g:2354:2: (iv_ruleSubProtocol= ruleSubProtocol EOF )
+            // InternalRoom.g:2355:2: iv_ruleSubProtocol= ruleSubProtocol EOF
             {
              newCompositeNode(grammarAccess.getSubProtocolRule()); 
             pushFollow(FOLLOW_1);
@@ -5707,7 +5864,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSubProtocol"
-    // InternalRoom.g:2301:1: ruleSubProtocol returns [EObject current=null] : (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
+    // InternalRoom.g:2362:1: ruleSubProtocol returns [EObject current=null] : (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
     public final EObject ruleSubProtocol() throws RecognitionException {
         EObject current = null;
 
@@ -5718,21 +5875,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2304:28: ( (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
-            // InternalRoom.g:2305:1: (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:2365:28: ( (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
+            // InternalRoom.g:2366:1: (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
             {
-            // InternalRoom.g:2305:1: (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
-            // InternalRoom.g:2305:3: otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
+            // InternalRoom.g:2366:1: (otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:2366:3: otherlv_0= 'SubProtocol' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
             {
             otherlv_0=(Token)match(input,49,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSubProtocolAccess().getSubProtocolKeyword_0());
                 
-            // InternalRoom.g:2309:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:2310:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:2370:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:2371:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:2310:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:2311:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:2371:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:2372:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -5758,11 +5915,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSubProtocolAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:2331:1: ( ( ruleFQN ) )
-            // InternalRoom.g:2332:1: ( ruleFQN )
+            // InternalRoom.g:2392:1: ( ( ruleFQN ) )
+            // InternalRoom.g:2393:1: ( ruleFQN )
             {
-            // InternalRoom.g:2332:1: ( ruleFQN )
-            // InternalRoom.g:2333:3: ruleFQN
+            // InternalRoom.g:2393:1: ( ruleFQN )
+            // InternalRoom.g:2394:3: ruleFQN
             {
 
             			if (current==null) {
@@ -5807,7 +5964,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMessage"
-    // InternalRoom.g:2354:1: entryRuleMessage returns [EObject current=null] : iv_ruleMessage= ruleMessage EOF ;
+    // InternalRoom.g:2415:1: entryRuleMessage returns [EObject current=null] : iv_ruleMessage= ruleMessage EOF ;
     public final EObject entryRuleMessage() throws RecognitionException {
         EObject current = null;
 
@@ -5815,8 +5972,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2355:2: (iv_ruleMessage= ruleMessage EOF )
-            // InternalRoom.g:2356:2: iv_ruleMessage= ruleMessage EOF
+            // InternalRoom.g:2416:2: (iv_ruleMessage= ruleMessage EOF )
+            // InternalRoom.g:2417:2: iv_ruleMessage= ruleMessage EOF
             {
              newCompositeNode(grammarAccess.getMessageRule()); 
             pushFollow(FOLLOW_1);
@@ -5843,7 +6000,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleMessage"
-    // InternalRoom.g:2363:1: ruleMessage returns [EObject current=null] : ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_data_4_0= ruleVarDecl ) )? otherlv_5= ')' ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:2424:1: ruleMessage returns [EObject current=null] : ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )? ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) ;
     public final EObject ruleMessage() throws RecognitionException {
         EObject current = null;
 
@@ -5862,25 +6019,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2366:28: ( ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_data_4_0= ruleVarDecl ) )? otherlv_5= ')' ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:2367:1: ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_data_4_0= ruleVarDecl ) )? otherlv_5= ')' ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
+            // InternalRoom.g:2427:28: ( ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )? ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:2428:1: ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )? ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:2367:1: ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_data_4_0= ruleVarDecl ) )? otherlv_5= ')' ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
-            // InternalRoom.g:2367:2: ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_data_4_0= ruleVarDecl ) )? otherlv_5= ')' ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )?
+            // InternalRoom.g:2428:1: ( ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )? ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
+            // InternalRoom.g:2428:2: ( (lv_priv_0_0= 'private' ) )? otherlv_1= 'Message' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )? ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )?
             {
-            // InternalRoom.g:2367:2: ( (lv_priv_0_0= 'private' ) )?
-            int alt59=2;
-            int LA59_0 = input.LA(1);
+            // InternalRoom.g:2428:2: ( (lv_priv_0_0= 'private' ) )?
+            int alt60=2;
+            int LA60_0 = input.LA(1);
 
-            if ( (LA59_0==50) ) {
-                alt59=1;
+            if ( (LA60_0==50) ) {
+                alt60=1;
             }
-            switch (alt59) {
+            switch (alt60) {
                 case 1 :
-                    // InternalRoom.g:2368:1: (lv_priv_0_0= 'private' )
+                    // InternalRoom.g:2429:1: (lv_priv_0_0= 'private' )
                     {
-                    // InternalRoom.g:2368:1: (lv_priv_0_0= 'private' )
-                    // InternalRoom.g:2369:3: lv_priv_0_0= 'private'
+                    // InternalRoom.g:2429:1: (lv_priv_0_0= 'private' )
+                    // InternalRoom.g:2430:3: lv_priv_0_0= 'private'
                     {
                     lv_priv_0_0=(Token)match(input,50,FOLLOW_64); 
 
@@ -5905,13 +6062,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getMessageAccess().getMessageKeyword_1());
                 
-            // InternalRoom.g:2386:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:2387:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:2447:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:2448:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:2387:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:2388:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:2448:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:2449:3: lv_name_2_0= RULE_ID
             {
-            lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_39); 
+            lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_65); 
 
             			newLeafNode(lv_name_2_0, grammarAccess.getMessageAccess().getNameIDTerminalRuleCall_2_0()); 
             		
@@ -5931,78 +6088,95 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,20,FOLLOW_40); 
-
-                	newLeafNode(otherlv_3, grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3());
-                
-            // InternalRoom.g:2408:1: ( (lv_data_4_0= ruleVarDecl ) )?
-            int alt60=2;
-            int LA60_0 = input.LA(1);
+            // InternalRoom.g:2465:2: (otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')' )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
 
-            if ( (LA60_0==RULE_ID) ) {
-                alt60=1;
+            if ( (LA62_0==20) ) {
+                alt62=1;
             }
-            switch (alt60) {
+            switch (alt62) {
                 case 1 :
-                    // InternalRoom.g:2409:1: (lv_data_4_0= ruleVarDecl )
-                    {
-                    // InternalRoom.g:2409:1: (lv_data_4_0= ruleVarDecl )
-                    // InternalRoom.g:2410:3: lv_data_4_0= ruleVarDecl
+                    // InternalRoom.g:2465:4: otherlv_3= '(' ( (lv_data_4_0= ruleMessageData ) )? otherlv_5= ')'
                     {
-                     
-                    	        newCompositeNode(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); 
-                    	    
-                    pushFollow(FOLLOW_14);
-                    lv_data_4_0=ruleVarDecl();
+                    otherlv_3=(Token)match(input,20,FOLLOW_40); 
 
-                    state._fsp--;
+                        	newLeafNode(otherlv_3, grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0());
+                        
+                    // InternalRoom.g:2469:1: ( (lv_data_4_0= ruleMessageData ) )?
+                    int alt61=2;
+                    int LA61_0 = input.LA(1);
 
+                    if ( (LA61_0==RULE_ID) ) {
+                        alt61=1;
+                    }
+                    switch (alt61) {
+                        case 1 :
+                            // InternalRoom.g:2470:1: (lv_data_4_0= ruleMessageData )
+                            {
+                            // InternalRoom.g:2470:1: (lv_data_4_0= ruleMessageData )
+                            // InternalRoom.g:2471:3: lv_data_4_0= ruleMessageData
+                            {
+                             
+                            	        newCompositeNode(grammarAccess.getMessageAccess().getDataMessageDataParserRuleCall_3_1_0()); 
+                            	    
+                            pushFollow(FOLLOW_14);
+                            lv_data_4_0=ruleMessageData();
 
-                    	        if (current==null) {
-                    	            current = createModelElementForParent(grammarAccess.getMessageRule());
-                    	        }
-                           		set(
-                           			current, 
-                           			"data",
-                            		lv_data_4_0, 
-                            		"org.eclipse.etrice.core.Room.VarDecl");
-                    	        afterParserOrEnumRuleCall();
-                    	    
+                            state._fsp--;
+
+
+                            	        if (current==null) {
+                            	            current = createModelElementForParent(grammarAccess.getMessageRule());
+                            	        }
+                                   		set(
+                                   			current, 
+                                   			"data",
+                                    		lv_data_4_0, 
+                                    		"org.eclipse.etrice.core.Room.MessageData");
+                            	        afterParserOrEnumRuleCall();
+                            	    
+
+                            }
+
+
+                            }
+                            break;
 
                     }
 
+                    otherlv_5=(Token)match(input,21,FOLLOW_66); 
+
+                        	newLeafNode(otherlv_5, grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2());
+                        
 
                     }
                     break;
 
             }
 
-            otherlv_5=(Token)match(input,21,FOLLOW_65); 
-
-                	newLeafNode(otherlv_5, grammarAccess.getMessageAccess().getRightParenthesisKeyword_5());
-                
-            // InternalRoom.g:2430:1: ( (lv_annotations_6_0= ruleAnnotation ) )*
-            loop61:
+            // InternalRoom.g:2491:3: ( (lv_annotations_6_0= ruleAnnotation ) )*
+            loop63:
             do {
-                int alt61=2;
-                int LA61_0 = input.LA(1);
+                int alt63=2;
+                int LA63_0 = input.LA(1);
 
-                if ( (LA61_0==108) ) {
-                    alt61=1;
+                if ( (LA63_0==108) ) {
+                    alt63=1;
                 }
 
 
-                switch (alt61) {
+                switch (alt63) {
             	case 1 :
-            	    // InternalRoom.g:2431:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:2492:1: (lv_annotations_6_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:2431:1: (lv_annotations_6_0= ruleAnnotation )
-            	    // InternalRoom.g:2432:3: lv_annotations_6_0= ruleAnnotation
+            	    // InternalRoom.g:2492:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:2493:3: lv_annotations_6_0= ruleAnnotation
             	    {
             	     
-            	    	        newCompositeNode(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
+            	    	        newCompositeNode(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_65);
+            	    pushFollow(FOLLOW_66);
             	    lv_annotations_6_0=ruleAnnotation();
 
             	    state._fsp--;
@@ -6026,26 +6200,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop61;
+            	    break loop63;
                 }
             } while (true);
 
-            // InternalRoom.g:2448:3: ( (lv_docu_7_0= ruleDocumentation ) )?
-            int alt62=2;
-            int LA62_0 = input.LA(1);
+            // InternalRoom.g:2509:3: ( (lv_docu_7_0= ruleDocumentation ) )?
+            int alt64=2;
+            int LA64_0 = input.LA(1);
 
-            if ( (LA62_0==34) ) {
-                alt62=1;
+            if ( (LA64_0==34) ) {
+                alt64=1;
             }
-            switch (alt62) {
+            switch (alt64) {
                 case 1 :
-                    // InternalRoom.g:2449:1: (lv_docu_7_0= ruleDocumentation )
+                    // InternalRoom.g:2510:1: (lv_docu_7_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:2449:1: (lv_docu_7_0= ruleDocumentation )
-                    // InternalRoom.g:2450:3: lv_docu_7_0= ruleDocumentation
+                    // InternalRoom.g:2510:1: (lv_docu_7_0= ruleDocumentation )
+                    // InternalRoom.g:2511:3: lv_docu_7_0= ruleDocumentation
                     {
                      
-                    	        newCompositeNode(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); 
+                    	        newCompositeNode(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_5_0()); 
                     	    
                     pushFollow(FOLLOW_2);
                     lv_docu_7_0=ruleDocumentation();
@@ -6093,7 +6267,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRulePortClass"
-    // InternalRoom.g:2474:1: entryRulePortClass returns [EObject current=null] : iv_rulePortClass= rulePortClass EOF ;
+    // InternalRoom.g:2535:1: entryRulePortClass returns [EObject current=null] : iv_rulePortClass= rulePortClass EOF ;
     public final EObject entryRulePortClass() throws RecognitionException {
         EObject current = null;
 
@@ -6101,8 +6275,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2475:2: (iv_rulePortClass= rulePortClass EOF )
-            // InternalRoom.g:2476:2: iv_rulePortClass= rulePortClass EOF
+            // InternalRoom.g:2536:2: (iv_rulePortClass= rulePortClass EOF )
+            // InternalRoom.g:2537:2: iv_rulePortClass= rulePortClass EOF
             {
              newCompositeNode(grammarAccess.getPortClassRule()); 
             pushFollow(FOLLOW_1);
@@ -6129,7 +6303,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "rulePortClass"
-    // InternalRoom.g:2483:1: rulePortClass returns [EObject current=null] : ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' ) ;
+    // InternalRoom.g:2544:1: rulePortClass returns [EObject current=null] : ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' ) ;
     public final EObject rulePortClass() throws RecognitionException {
         EObject current = null;
 
@@ -6148,14 +6322,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2486:28: ( ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' ) )
-            // InternalRoom.g:2487:1: ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' )
+            // InternalRoom.g:2547:28: ( ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' ) )
+            // InternalRoom.g:2548:1: ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' )
             {
-            // InternalRoom.g:2487:1: ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' )
-            // InternalRoom.g:2487:2: () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}'
+            // InternalRoom.g:2548:1: ( () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}' )
+            // InternalRoom.g:2548:2: () otherlv_1= '{' (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )? ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )* otherlv_7= '}'
             {
-            // InternalRoom.g:2487:2: ()
-            // InternalRoom.g:2488:5: 
+            // InternalRoom.g:2548:2: ()
+            // InternalRoom.g:2549:5: 
             {
 
                     current = forceCreateModelElement(
@@ -6165,35 +6339,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_1=(Token)match(input,14,FOLLOW_66); 
+            otherlv_1=(Token)match(input,14,FOLLOW_67); 
 
                 	newLeafNode(otherlv_1, grammarAccess.getPortClassAccess().getLeftCurlyBracketKeyword_1());
                 
-            // InternalRoom.g:2497:1: (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )?
-            int alt63=2;
-            int LA63_0 = input.LA(1);
+            // InternalRoom.g:2558:1: (otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) ) )?
+            int alt65=2;
+            int LA65_0 = input.LA(1);
 
-            if ( (LA63_0==52) ) {
-                alt63=1;
+            if ( (LA65_0==52) ) {
+                alt65=1;
             }
-            switch (alt63) {
+            switch (alt65) {
                 case 1 :
-                    // InternalRoom.g:2497:3: otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) )
+                    // InternalRoom.g:2558:3: otherlv_2= 'usercode' ( (lv_userCode_3_0= ruleDetailCode ) )
                     {
-                    otherlv_2=(Token)match(input,52,FOLLOW_67); 
+                    otherlv_2=(Token)match(input,52,FOLLOW_68); 
 
                         	newLeafNode(otherlv_2, grammarAccess.getPortClassAccess().getUsercodeKeyword_2_0());
                         
-                    // InternalRoom.g:2501:1: ( (lv_userCode_3_0= ruleDetailCode ) )
-                    // InternalRoom.g:2502:1: (lv_userCode_3_0= ruleDetailCode )
+                    // InternalRoom.g:2562:1: ( (lv_userCode_3_0= ruleDetailCode ) )
+                    // InternalRoom.g:2563:1: (lv_userCode_3_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:2502:1: (lv_userCode_3_0= ruleDetailCode )
-                    // InternalRoom.g:2503:3: lv_userCode_3_0= ruleDetailCode
+                    // InternalRoom.g:2563:1: (lv_userCode_3_0= ruleDetailCode )
+                    // InternalRoom.g:2564:3: lv_userCode_3_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getPortClassAccess().getUserCodeDetailCodeParserRuleCall_2_1_0()); 
                     	    
-                    pushFollow(FOLLOW_68);
+                    pushFollow(FOLLOW_69);
                     lv_userCode_3_0=ruleDetailCode();
 
                     state._fsp--;
@@ -6221,43 +6395,43 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2519:4: ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )*
-            loop64:
+            // InternalRoom.g:2580:4: ( ( (lv_msgHandlers_4_0= ruleMessageHandler ) ) | ( (lv_operations_5_0= rulePortOperation ) ) | ( (lv_attributes_6_0= ruleAttribute ) ) )*
+            loop66:
             do {
-                int alt64=4;
+                int alt66=4;
                 switch ( input.LA(1) ) {
                 case 53:
                     {
-                    alt64=1;
+                    alt66=1;
                     }
                     break;
                 case 37:
                     {
-                    alt64=2;
+                    alt66=2;
                     }
                     break;
                 case 33:
                     {
-                    alt64=3;
+                    alt66=3;
                     }
                     break;
 
                 }
 
-                switch (alt64) {
+                switch (alt66) {
             	case 1 :
-            	    // InternalRoom.g:2519:5: ( (lv_msgHandlers_4_0= ruleMessageHandler ) )
+            	    // InternalRoom.g:2580:5: ( (lv_msgHandlers_4_0= ruleMessageHandler ) )
             	    {
-            	    // InternalRoom.g:2519:5: ( (lv_msgHandlers_4_0= ruleMessageHandler ) )
-            	    // InternalRoom.g:2520:1: (lv_msgHandlers_4_0= ruleMessageHandler )
+            	    // InternalRoom.g:2580:5: ( (lv_msgHandlers_4_0= ruleMessageHandler ) )
+            	    // InternalRoom.g:2581:1: (lv_msgHandlers_4_0= ruleMessageHandler )
             	    {
-            	    // InternalRoom.g:2520:1: (lv_msgHandlers_4_0= ruleMessageHandler )
-            	    // InternalRoom.g:2521:3: lv_msgHandlers_4_0= ruleMessageHandler
+            	    // InternalRoom.g:2581:1: (lv_msgHandlers_4_0= ruleMessageHandler )
+            	    // InternalRoom.g:2582:3: lv_msgHandlers_4_0= ruleMessageHandler
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getPortClassAccess().getMsgHandlersMessageHandlerParserRuleCall_3_0_0()); 
             	    	    
-            	    pushFollow(FOLLOW_68);
+            	    pushFollow(FOLLOW_69);
             	    lv_msgHandlers_4_0=ruleMessageHandler();
 
             	    state._fsp--;
@@ -6283,18 +6457,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:2538:6: ( (lv_operations_5_0= rulePortOperation ) )
+            	    // InternalRoom.g:2599:6: ( (lv_operations_5_0= rulePortOperation ) )
             	    {
-            	    // InternalRoom.g:2538:6: ( (lv_operations_5_0= rulePortOperation ) )
-            	    // InternalRoom.g:2539:1: (lv_operations_5_0= rulePortOperation )
+            	    // InternalRoom.g:2599:6: ( (lv_operations_5_0= rulePortOperation ) )
+            	    // InternalRoom.g:2600:1: (lv_operations_5_0= rulePortOperation )
             	    {
-            	    // InternalRoom.g:2539:1: (lv_operations_5_0= rulePortOperation )
-            	    // InternalRoom.g:2540:3: lv_operations_5_0= rulePortOperation
+            	    // InternalRoom.g:2600:1: (lv_operations_5_0= rulePortOperation )
+            	    // InternalRoom.g:2601:3: lv_operations_5_0= rulePortOperation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getPortClassAccess().getOperationsPortOperationParserRuleCall_3_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_68);
+            	    pushFollow(FOLLOW_69);
             	    lv_operations_5_0=rulePortOperation();
 
             	    state._fsp--;
@@ -6320,18 +6494,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:2557:6: ( (lv_attributes_6_0= ruleAttribute ) )
+            	    // InternalRoom.g:2618:6: ( (lv_attributes_6_0= ruleAttribute ) )
             	    {
-            	    // InternalRoom.g:2557:6: ( (lv_attributes_6_0= ruleAttribute ) )
-            	    // InternalRoom.g:2558:1: (lv_attributes_6_0= ruleAttribute )
+            	    // InternalRoom.g:2618:6: ( (lv_attributes_6_0= ruleAttribute ) )
+            	    // InternalRoom.g:2619:1: (lv_attributes_6_0= ruleAttribute )
             	    {
-            	    // InternalRoom.g:2558:1: (lv_attributes_6_0= ruleAttribute )
-            	    // InternalRoom.g:2559:3: lv_attributes_6_0= ruleAttribute
+            	    // InternalRoom.g:2619:1: (lv_attributes_6_0= ruleAttribute )
+            	    // InternalRoom.g:2620:3: lv_attributes_6_0= ruleAttribute
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getPortClassAccess().getAttributesAttributeParserRuleCall_3_2_0()); 
             	    	    
-            	    pushFollow(FOLLOW_68);
+            	    pushFollow(FOLLOW_69);
             	    lv_attributes_6_0=ruleAttribute();
 
             	    state._fsp--;
@@ -6358,7 +6532,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop64;
+            	    break loop66;
                 }
             } while (true);
 
@@ -6387,7 +6561,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMessageHandler"
-    // InternalRoom.g:2587:1: entryRuleMessageHandler returns [EObject current=null] : iv_ruleMessageHandler= ruleMessageHandler EOF ;
+    // InternalRoom.g:2648:1: entryRuleMessageHandler returns [EObject current=null] : iv_ruleMessageHandler= ruleMessageHandler EOF ;
     public final EObject entryRuleMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6395,8 +6569,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2588:2: (iv_ruleMessageHandler= ruleMessageHandler EOF )
-            // InternalRoom.g:2589:2: iv_ruleMessageHandler= ruleMessageHandler EOF
+            // InternalRoom.g:2649:2: (iv_ruleMessageHandler= ruleMessageHandler EOF )
+            // InternalRoom.g:2650:2: iv_ruleMessageHandler= ruleMessageHandler EOF
             {
              newCompositeNode(grammarAccess.getMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -6423,7 +6597,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleMessageHandler"
-    // InternalRoom.g:2596:1: ruleMessageHandler returns [EObject current=null] : (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler ) ;
+    // InternalRoom.g:2657:1: ruleMessageHandler returns [EObject current=null] : (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler ) ;
     public final EObject ruleMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6435,38 +6609,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2599:28: ( (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler ) )
-            // InternalRoom.g:2600:1: (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler )
+            // InternalRoom.g:2660:28: ( (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler ) )
+            // InternalRoom.g:2661:1: (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler )
             {
-            // InternalRoom.g:2600:1: (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler )
-            int alt65=2;
-            int LA65_0 = input.LA(1);
+            // InternalRoom.g:2661:1: (this_InMessageHandler_0= ruleInMessageHandler | this_OutMessageHandler_1= ruleOutMessageHandler )
+            int alt67=2;
+            int LA67_0 = input.LA(1);
 
-            if ( (LA65_0==53) ) {
-                int LA65_1 = input.LA(2);
+            if ( (LA67_0==53) ) {
+                int LA67_1 = input.LA(2);
 
-                if ( (LA65_1==44) ) {
-                    alt65=2;
+                if ( (LA67_1==44) ) {
+                    alt67=2;
                 }
-                else if ( (LA65_1==43) ) {
-                    alt65=1;
+                else if ( (LA67_1==43) ) {
+                    alt67=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 65, 1, input);
+                        new NoViableAltException("", 67, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 65, 0, input);
+                    new NoViableAltException("", 67, 0, input);
 
                 throw nvae;
             }
-            switch (alt65) {
+            switch (alt67) {
                 case 1 :
-                    // InternalRoom.g:2601:5: this_InMessageHandler_0= ruleInMessageHandler
+                    // InternalRoom.g:2662:5: this_InMessageHandler_0= ruleInMessageHandler
                     {
                      
                             newCompositeNode(grammarAccess.getMessageHandlerAccess().getInMessageHandlerParserRuleCall_0()); 
@@ -6484,7 +6658,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:2611:5: this_OutMessageHandler_1= ruleOutMessageHandler
+                    // InternalRoom.g:2672:5: this_OutMessageHandler_1= ruleOutMessageHandler
                     {
                      
                             newCompositeNode(grammarAccess.getMessageHandlerAccess().getOutMessageHandlerParserRuleCall_1()); 
@@ -6522,7 +6696,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInMessageHandler"
-    // InternalRoom.g:2627:1: entryRuleInMessageHandler returns [EObject current=null] : iv_ruleInMessageHandler= ruleInMessageHandler EOF ;
+    // InternalRoom.g:2688:1: entryRuleInMessageHandler returns [EObject current=null] : iv_ruleInMessageHandler= ruleInMessageHandler EOF ;
     public final EObject entryRuleInMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6530,8 +6704,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2628:2: (iv_ruleInMessageHandler= ruleInMessageHandler EOF )
-            // InternalRoom.g:2629:2: iv_ruleInMessageHandler= ruleInMessageHandler EOF
+            // InternalRoom.g:2689:2: (iv_ruleInMessageHandler= ruleInMessageHandler EOF )
+            // InternalRoom.g:2690:2: iv_ruleInMessageHandler= ruleInMessageHandler EOF
             {
              newCompositeNode(grammarAccess.getInMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -6558,7 +6732,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInMessageHandler"
-    // InternalRoom.g:2636:1: ruleInMessageHandler returns [EObject current=null] : (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:2697:1: ruleInMessageHandler returns [EObject current=null] : (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) ;
     public final EObject ruleInMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6571,13 +6745,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2639:28: ( (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:2640:1: (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
+            // InternalRoom.g:2700:28: ( (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:2701:1: (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:2640:1: (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
-            // InternalRoom.g:2640:3: otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) )
+            // InternalRoom.g:2701:1: (otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
+            // InternalRoom.g:2701:3: otherlv_0= 'handle' otherlv_1= 'incoming' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) )
             {
-            otherlv_0=(Token)match(input,53,FOLLOW_69); 
+            otherlv_0=(Token)match(input,53,FOLLOW_70); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getInMessageHandlerAccess().getHandleKeyword_0());
                 
@@ -6585,11 +6759,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getInMessageHandlerAccess().getIncomingKeyword_1());
                 
-            // InternalRoom.g:2648:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:2649:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:2709:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:2710:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:2649:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:2650:3: otherlv_2= RULE_ID
+            // InternalRoom.g:2710:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:2711:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -6606,11 +6780,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2661:2: ( (lv_detailCode_3_0= ruleDetailCode ) )
-            // InternalRoom.g:2662:1: (lv_detailCode_3_0= ruleDetailCode )
+            // InternalRoom.g:2722:2: ( (lv_detailCode_3_0= ruleDetailCode ) )
+            // InternalRoom.g:2723:1: (lv_detailCode_3_0= ruleDetailCode )
             {
-            // InternalRoom.g:2662:1: (lv_detailCode_3_0= ruleDetailCode )
-            // InternalRoom.g:2663:3: lv_detailCode_3_0= ruleDetailCode
+            // InternalRoom.g:2723:1: (lv_detailCode_3_0= ruleDetailCode )
+            // InternalRoom.g:2724:3: lv_detailCode_3_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
@@ -6658,7 +6832,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleOutMessageHandler"
-    // InternalRoom.g:2687:1: entryRuleOutMessageHandler returns [EObject current=null] : iv_ruleOutMessageHandler= ruleOutMessageHandler EOF ;
+    // InternalRoom.g:2748:1: entryRuleOutMessageHandler returns [EObject current=null] : iv_ruleOutMessageHandler= ruleOutMessageHandler EOF ;
     public final EObject entryRuleOutMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6666,8 +6840,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2688:2: (iv_ruleOutMessageHandler= ruleOutMessageHandler EOF )
-            // InternalRoom.g:2689:2: iv_ruleOutMessageHandler= ruleOutMessageHandler EOF
+            // InternalRoom.g:2749:2: (iv_ruleOutMessageHandler= ruleOutMessageHandler EOF )
+            // InternalRoom.g:2750:2: iv_ruleOutMessageHandler= ruleOutMessageHandler EOF
             {
              newCompositeNode(grammarAccess.getOutMessageHandlerRule()); 
             pushFollow(FOLLOW_1);
@@ -6694,7 +6868,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleOutMessageHandler"
-    // InternalRoom.g:2696:1: ruleOutMessageHandler returns [EObject current=null] : (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:2757:1: ruleOutMessageHandler returns [EObject current=null] : (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) ;
     public final EObject ruleOutMessageHandler() throws RecognitionException {
         EObject current = null;
 
@@ -6707,13 +6881,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2699:28: ( (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:2700:1: (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
+            // InternalRoom.g:2760:28: ( (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:2761:1: (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:2700:1: (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
-            // InternalRoom.g:2700:3: otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) )
+            // InternalRoom.g:2761:1: (otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) ) )
+            // InternalRoom.g:2761:3: otherlv_0= 'handle' otherlv_1= 'outgoing' ( (otherlv_2= RULE_ID ) ) ( (lv_detailCode_3_0= ruleDetailCode ) )
             {
-            otherlv_0=(Token)match(input,53,FOLLOW_70); 
+            otherlv_0=(Token)match(input,53,FOLLOW_71); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getOutMessageHandlerAccess().getHandleKeyword_0());
                 
@@ -6721,11 +6895,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getOutMessageHandlerAccess().getOutgoingKeyword_1());
                 
-            // InternalRoom.g:2708:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:2709:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:2769:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:2770:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:2709:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:2710:3: otherlv_2= RULE_ID
+            // InternalRoom.g:2770:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:2771:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -6742,11 +6916,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2721:2: ( (lv_detailCode_3_0= ruleDetailCode ) )
-            // InternalRoom.g:2722:1: (lv_detailCode_3_0= ruleDetailCode )
+            // InternalRoom.g:2782:2: ( (lv_detailCode_3_0= ruleDetailCode ) )
+            // InternalRoom.g:2783:1: (lv_detailCode_3_0= ruleDetailCode )
             {
-            // InternalRoom.g:2722:1: (lv_detailCode_3_0= ruleDetailCode )
-            // InternalRoom.g:2723:3: lv_detailCode_3_0= ruleDetailCode
+            // InternalRoom.g:2783:1: (lv_detailCode_3_0= ruleDetailCode )
+            // InternalRoom.g:2784:3: lv_detailCode_3_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
@@ -6794,7 +6968,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleModelComponent"
-    // InternalRoom.g:2747:1: entryRuleModelComponent returns [EObject current=null] : iv_ruleModelComponent= ruleModelComponent EOF ;
+    // InternalRoom.g:2808:1: entryRuleModelComponent returns [EObject current=null] : iv_ruleModelComponent= ruleModelComponent EOF ;
     public final EObject entryRuleModelComponent() throws RecognitionException {
         EObject current = null;
 
@@ -6802,8 +6976,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2748:2: (iv_ruleModelComponent= ruleModelComponent EOF )
-            // InternalRoom.g:2749:2: iv_ruleModelComponent= ruleModelComponent EOF
+            // InternalRoom.g:2809:2: (iv_ruleModelComponent= ruleModelComponent EOF )
+            // InternalRoom.g:2810:2: iv_ruleModelComponent= ruleModelComponent EOF
             {
              newCompositeNode(grammarAccess.getModelComponentRule()); 
             pushFollow(FOLLOW_1);
@@ -6830,7 +7004,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleModelComponent"
-    // InternalRoom.g:2756:1: ruleModelComponent returns [EObject current=null] : this_ActorClass_0= ruleActorClass ;
+    // InternalRoom.g:2817:1: ruleModelComponent returns [EObject current=null] : this_ActorClass_0= ruleActorClass ;
     public final EObject ruleModelComponent() throws RecognitionException {
         EObject current = null;
 
@@ -6840,8 +7014,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2759:28: (this_ActorClass_0= ruleActorClass )
-            // InternalRoom.g:2761:5: this_ActorClass_0= ruleActorClass
+            // InternalRoom.g:2820:28: (this_ActorClass_0= ruleActorClass )
+            // InternalRoom.g:2822:5: this_ActorClass_0= ruleActorClass
             {
              
                     newCompositeNode(grammarAccess.getModelComponentAccess().getActorClassParserRuleCall()); 
@@ -6873,7 +7047,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleActorClass"
-    // InternalRoom.g:2777:1: entryRuleActorClass returns [EObject current=null] : iv_ruleActorClass= ruleActorClass EOF ;
+    // InternalRoom.g:2838:1: entryRuleActorClass returns [EObject current=null] : iv_ruleActorClass= ruleActorClass EOF ;
     public final EObject entryRuleActorClass() throws RecognitionException {
         EObject current = null;
 
@@ -6881,8 +7055,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:2778:2: (iv_ruleActorClass= ruleActorClass EOF )
-            // InternalRoom.g:2779:2: iv_ruleActorClass= ruleActorClass EOF
+            // InternalRoom.g:2839:2: (iv_ruleActorClass= ruleActorClass EOF )
+            // InternalRoom.g:2840:2: iv_ruleActorClass= ruleActorClass EOF
             {
              newCompositeNode(grammarAccess.getActorClassRule()); 
             pushFollow(FOLLOW_1);
@@ -6909,7 +7083,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleActorClass"
-    // InternalRoom.g:2786:1: ruleActorClass returns [EObject current=null] : ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' ) ;
+    // InternalRoom.g:2847:1: ruleActorClass returns [EObject current=null] : ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' ) ;
     public final EObject ruleActorClass() throws RecognitionException {
         EObject current = null;
 
@@ -6979,67 +7153,67 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:2789:28: ( ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' ) )
-            // InternalRoom.g:2790:1: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' )
+            // InternalRoom.g:2850:28: ( ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' ) )
+            // InternalRoom.g:2851:1: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' )
             {
-            // InternalRoom.g:2790:1: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' )
-            // InternalRoom.g:2790:2: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}'
+            // InternalRoom.g:2851:1: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}' )
+            // InternalRoom.g:2851:2: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) ) otherlv_3= 'ActorClass' ( (lv_name_4_0= RULE_ID ) ) ( (lv_docu_5_0= ruleDocumentation ) )? (otherlv_6= 'extends' ( ( ruleFQN ) ) )? otherlv_8= '{' ( (lv_annotations_9_0= ruleAnnotation ) )* (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )? (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )? (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )? otherlv_41= '}'
             {
-            // InternalRoom.g:2790:2: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) )
-            // InternalRoom.g:2792:1: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) )
+            // InternalRoom.g:2851:2: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) ) )
+            // InternalRoom.g:2853:1: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) )
             {
-            // InternalRoom.g:2792:1: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) )
-            // InternalRoom.g:2793:2: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* )
+            // InternalRoom.g:2853:1: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* ) )
+            // InternalRoom.g:2854:2: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* )
             {
              
             	  getUnorderedGroupHelper().enter(grammarAccess.getActorClassAccess().getUnorderedGroup_0());
             	
-            // InternalRoom.g:2796:2: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* )
-            // InternalRoom.g:2797:3: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )*
+            // InternalRoom.g:2857:2: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )* )
+            // InternalRoom.g:2858:3: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )*
             {
-            // InternalRoom.g:2797:3: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )*
-            loop66:
+            // InternalRoom.g:2858:3: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) ) )*
+            loop68:
             do {
-                int alt66=3;
-                int LA66_0 = input.LA(1);
+                int alt68=3;
+                int LA68_0 = input.LA(1);
 
-                if ( LA66_0 == 54 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                    alt66=1;
+                if ( LA68_0 == 54 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                    alt68=1;
                 }
-                else if ( ( LA66_0 >= 124 && LA66_0 <= 126 || LA66_0 == 128 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                    alt66=2;
+                else if ( ( LA68_0 >= 124 && LA68_0 <= 126 || LA68_0 == 128 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                    alt68=2;
                 }
 
 
-                switch (alt66) {
+                switch (alt68) {
             	case 1 :
-            	    // InternalRoom.g:2799:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) )
+            	    // InternalRoom.g:2860:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) )
             	    {
-            	    // InternalRoom.g:2799:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) )
-            	    // InternalRoom.g:2800:5: {...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) )
+            	    // InternalRoom.g:2860:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) ) )
+            	    // InternalRoom.g:2861:5: {...}? => ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) )
             	    {
             	    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
             	        throw new FailedPredicateException(input, "ruleActorClass", "getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0)");
             	    }
-            	    // InternalRoom.g:2800:107: ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) )
-            	    // InternalRoom.g:2801:6: ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) )
+            	    // InternalRoom.g:2861:107: ( ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) ) )
+            	    // InternalRoom.g:2862:6: ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) )
             	    {
             	     
             	    	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0);
             	    	 				
-            	    // InternalRoom.g:2804:6: ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) )
-            	    // InternalRoom.g:2804:7: {...}? => ( (lv_abstract_1_0= 'abstract' ) )
+            	    // InternalRoom.g:2865:6: ({...}? => ( (lv_abstract_1_0= 'abstract' ) ) )
+            	    // InternalRoom.g:2865:7: {...}? => ( (lv_abstract_1_0= 'abstract' ) )
             	    {
             	    if ( !((true)) ) {
             	        throw new FailedPredicateException(input, "ruleActorClass", "true");
             	    }
-            	    // InternalRoom.g:2804:16: ( (lv_abstract_1_0= 'abstract' ) )
-            	    // InternalRoom.g:2805:1: (lv_abstract_1_0= 'abstract' )
+            	    // InternalRoom.g:2865:16: ( (lv_abstract_1_0= 'abstract' ) )
+            	    // InternalRoom.g:2866:1: (lv_abstract_1_0= 'abstract' )
             	    {
-            	    // InternalRoom.g:2805:1: (lv_abstract_1_0= 'abstract' )
-            	    // InternalRoom.g:2806:3: lv_abstract_1_0= 'abstract'
+            	    // InternalRoom.g:2866:1: (lv_abstract_1_0= 'abstract' )
+            	    // InternalRoom.g:2867:3: lv_abstract_1_0= 'abstract'
             	    {
-            	    lv_abstract_1_0=(Token)match(input,54,FOLLOW_71); 
+            	    lv_abstract_1_0=(Token)match(input,54,FOLLOW_72); 
 
             	            newLeafNode(lv_abstract_1_0, grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0());
             	        
@@ -7071,36 +7245,36 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:2826:4: ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) )
+            	    // InternalRoom.g:2887:4: ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) )
             	    {
-            	    // InternalRoom.g:2826:4: ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) )
-            	    // InternalRoom.g:2827:5: {...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) )
+            	    // InternalRoom.g:2887:4: ({...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) ) )
+            	    // InternalRoom.g:2888:5: {...}? => ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) )
             	    {
             	    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
             	        throw new FailedPredicateException(input, "ruleActorClass", "getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1)");
             	    }
-            	    // InternalRoom.g:2827:107: ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) )
-            	    // InternalRoom.g:2828:6: ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) )
+            	    // InternalRoom.g:2888:107: ( ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) ) )
+            	    // InternalRoom.g:2889:6: ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) )
             	    {
             	     
             	    	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1);
             	    	 				
-            	    // InternalRoom.g:2831:6: ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) )
-            	    // InternalRoom.g:2831:7: {...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) )
+            	    // InternalRoom.g:2892:6: ({...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) ) )
+            	    // InternalRoom.g:2892:7: {...}? => ( (lv_commType_2_0= ruleComponentCommunicationType ) )
             	    {
             	    if ( !((true)) ) {
             	        throw new FailedPredicateException(input, "ruleActorClass", "true");
             	    }
-            	    // InternalRoom.g:2831:16: ( (lv_commType_2_0= ruleComponentCommunicationType ) )
-            	    // InternalRoom.g:2832:1: (lv_commType_2_0= ruleComponentCommunicationType )
+            	    // InternalRoom.g:2892:16: ( (lv_commType_2_0= ruleComponentCommunicationType ) )
+            	    // InternalRoom.g:2893:1: (lv_commType_2_0= ruleComponentCommunicationType )
             	    {
-            	    // InternalRoom.g:2832:1: (lv_commType_2_0= ruleComponentCommunicationType )
-            	    // InternalRoom.g:2833:3: lv_commType_2_0= ruleComponentCommunicationType
+            	    // InternalRoom.g:2893:1: (lv_commType_2_0= ruleComponentCommunicationType )
+            	    // InternalRoom.g:2894:3: lv_commType_2_0= ruleComponentCommunicationType
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getActorClassAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_71);
+            	    pushFollow(FOLLOW_72);
             	    lv_commType_2_0=ruleComponentCommunicationType();
 
             	    state._fsp--;
@@ -7139,7 +7313,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop66;
+            	    break loop68;
                 }
             } while (true);
 
@@ -7159,11 +7333,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_3, grammarAccess.getActorClassAccess().getActorClassKeyword_1());
                 
-            // InternalRoom.g:2867:1: ( (lv_name_4_0= RULE_ID ) )
-            // InternalRoom.g:2868:1: (lv_name_4_0= RULE_ID )
+            // InternalRoom.g:2928:1: ( (lv_name_4_0= RULE_ID ) )
+            // InternalRoom.g:2929:1: (lv_name_4_0= RULE_ID )
             {
-            // InternalRoom.g:2868:1: (lv_name_4_0= RULE_ID )
-            // InternalRoom.g:2869:3: lv_name_4_0= RULE_ID
+            // InternalRoom.g:2929:1: (lv_name_4_0= RULE_ID )
+            // InternalRoom.g:2930:3: lv_name_4_0= RULE_ID
             {
             lv_name_4_0=(Token)match(input,RULE_ID,FOLLOW_24); 
 
@@ -7185,19 +7359,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2885:2: ( (lv_docu_5_0= ruleDocumentation ) )?
-            int alt67=2;
-            int LA67_0 = input.LA(1);
+            // InternalRoom.g:2946:2: ( (lv_docu_5_0= ruleDocumentation ) )?
+            int alt69=2;
+            int LA69_0 = input.LA(1);
 
-            if ( (LA67_0==34) ) {
-                alt67=1;
+            if ( (LA69_0==34) ) {
+                alt69=1;
             }
-            switch (alt67) {
+            switch (alt69) {
                 case 1 :
-                    // InternalRoom.g:2886:1: (lv_docu_5_0= ruleDocumentation )
+                    // InternalRoom.g:2947:1: (lv_docu_5_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:2886:1: (lv_docu_5_0= ruleDocumentation )
-                    // InternalRoom.g:2887:3: lv_docu_5_0= ruleDocumentation
+                    // InternalRoom.g:2947:1: (lv_docu_5_0= ruleDocumentation )
+                    // InternalRoom.g:2948:3: lv_docu_5_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getActorClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
@@ -7227,26 +7401,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2903:3: (otherlv_6= 'extends' ( ( ruleFQN ) ) )?
-            int alt68=2;
-            int LA68_0 = input.LA(1);
+            // InternalRoom.g:2964:3: (otherlv_6= 'extends' ( ( ruleFQN ) ) )?
+            int alt70=2;
+            int LA70_0 = input.LA(1);
 
-            if ( (LA68_0==29) ) {
-                alt68=1;
+            if ( (LA70_0==29) ) {
+                alt70=1;
             }
-            switch (alt68) {
+            switch (alt70) {
                 case 1 :
-                    // InternalRoom.g:2903:5: otherlv_6= 'extends' ( ( ruleFQN ) )
+                    // InternalRoom.g:2964:5: otherlv_6= 'extends' ( ( ruleFQN ) )
                     {
                     otherlv_6=(Token)match(input,29,FOLLOW_3); 
 
                         	newLeafNode(otherlv_6, grammarAccess.getActorClassAccess().getExtendsKeyword_4_0());
                         
-                    // InternalRoom.g:2907:1: ( ( ruleFQN ) )
-                    // InternalRoom.g:2908:1: ( ruleFQN )
+                    // InternalRoom.g:2968:1: ( ( ruleFQN ) )
+                    // InternalRoom.g:2969:1: ( ruleFQN )
                     {
-                    // InternalRoom.g:2908:1: ( ruleFQN )
-                    // InternalRoom.g:2909:3: ruleFQN
+                    // InternalRoom.g:2969:1: ( ruleFQN )
+                    // InternalRoom.g:2970:3: ruleFQN
                     {
 
                     			if (current==null) {
@@ -7276,32 +7450,32 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_8=(Token)match(input,14,FOLLOW_72); 
+            otherlv_8=(Token)match(input,14,FOLLOW_73); 
 
                 	newLeafNode(otherlv_8, grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_5());
                 
-            // InternalRoom.g:2926:1: ( (lv_annotations_9_0= ruleAnnotation ) )*
-            loop69:
+            // InternalRoom.g:2987:1: ( (lv_annotations_9_0= ruleAnnotation ) )*
+            loop71:
             do {
-                int alt69=2;
-                int LA69_0 = input.LA(1);
+                int alt71=2;
+                int LA71_0 = input.LA(1);
 
-                if ( (LA69_0==108) ) {
-                    alt69=1;
+                if ( (LA71_0==108) ) {
+                    alt71=1;
                 }
 
 
-                switch (alt69) {
+                switch (alt71) {
             	case 1 :
-            	    // InternalRoom.g:2927:1: (lv_annotations_9_0= ruleAnnotation )
+            	    // InternalRoom.g:2988:1: (lv_annotations_9_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:2927:1: (lv_annotations_9_0= ruleAnnotation )
-            	    // InternalRoom.g:2928:3: lv_annotations_9_0= ruleAnnotation
+            	    // InternalRoom.g:2988:1: (lv_annotations_9_0= ruleAnnotation )
+            	    // InternalRoom.g:2989:3: lv_annotations_9_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getActorClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             	    	    
-            	    pushFollow(FOLLOW_72);
+            	    pushFollow(FOLLOW_73);
             	    lv_annotations_9_0=ruleAnnotation();
 
             	    state._fsp--;
@@ -7325,57 +7499,57 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop69;
+            	    break loop71;
                 }
             } while (true);
 
-            // InternalRoom.g:2944:3: (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )?
-            int alt71=2;
-            int LA71_0 = input.LA(1);
+            // InternalRoom.g:3005:3: (otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}' )?
+            int alt73=2;
+            int LA73_0 = input.LA(1);
 
-            if ( (LA71_0==56) ) {
-                alt71=1;
+            if ( (LA73_0==56) ) {
+                alt73=1;
             }
-            switch (alt71) {
+            switch (alt73) {
                 case 1 :
-                    // InternalRoom.g:2944:5: otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}'
+                    // InternalRoom.g:3005:5: otherlv_10= 'Interface' otherlv_11= '{' ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )* otherlv_14= '}'
                     {
                     otherlv_10=(Token)match(input,56,FOLLOW_5); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getActorClassAccess().getInterfaceKeyword_7_0());
                         
-                    otherlv_11=(Token)match(input,14,FOLLOW_73); 
+                    otherlv_11=(Token)match(input,14,FOLLOW_74); 
 
                         	newLeafNode(otherlv_11, grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_7_1());
                         
-                    // InternalRoom.g:2952:1: ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )*
-                    loop70:
+                    // InternalRoom.g:3013:1: ( ( (lv_serviceProvisionPoints_12_0= ruleSPP ) ) | ( (lv_interfacePorts_13_0= rulePort ) ) )*
+                    loop72:
                     do {
-                        int alt70=3;
-                        int LA70_0 = input.LA(1);
+                        int alt72=3;
+                        int LA72_0 = input.LA(1);
 
-                        if ( (LA70_0==62) ) {
-                            alt70=1;
+                        if ( (LA72_0==62) ) {
+                            alt72=1;
                         }
-                        else if ( (LA70_0==47||LA70_0==59) ) {
-                            alt70=2;
+                        else if ( (LA72_0==47||LA72_0==59) ) {
+                            alt72=2;
                         }
 
 
-                        switch (alt70) {
+                        switch (alt72) {
                     	case 1 :
-                    	    // InternalRoom.g:2952:2: ( (lv_serviceProvisionPoints_12_0= ruleSPP ) )
+                    	    // InternalRoom.g:3013:2: ( (lv_serviceProvisionPoints_12_0= ruleSPP ) )
                     	    {
-                    	    // InternalRoom.g:2952:2: ( (lv_serviceProvisionPoints_12_0= ruleSPP ) )
-                    	    // InternalRoom.g:2953:1: (lv_serviceProvisionPoints_12_0= ruleSPP )
+                    	    // InternalRoom.g:3013:2: ( (lv_serviceProvisionPoints_12_0= ruleSPP ) )
+                    	    // InternalRoom.g:3014:1: (lv_serviceProvisionPoints_12_0= ruleSPP )
                     	    {
-                    	    // InternalRoom.g:2953:1: (lv_serviceProvisionPoints_12_0= ruleSPP )
-                    	    // InternalRoom.g:2954:3: lv_serviceProvisionPoints_12_0= ruleSPP
+                    	    // InternalRoom.g:3014:1: (lv_serviceProvisionPoints_12_0= ruleSPP )
+                    	    // InternalRoom.g:3015:3: lv_serviceProvisionPoints_12_0= ruleSPP
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getServiceProvisionPointsSPPParserRuleCall_7_2_0_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_73);
+                    	    pushFollow(FOLLOW_74);
                     	    lv_serviceProvisionPoints_12_0=ruleSPP();
 
                     	    state._fsp--;
@@ -7401,18 +7575,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:2971:6: ( (lv_interfacePorts_13_0= rulePort ) )
+                    	    // InternalRoom.g:3032:6: ( (lv_interfacePorts_13_0= rulePort ) )
                     	    {
-                    	    // InternalRoom.g:2971:6: ( (lv_interfacePorts_13_0= rulePort ) )
-                    	    // InternalRoom.g:2972:1: (lv_interfacePorts_13_0= rulePort )
+                    	    // InternalRoom.g:3032:6: ( (lv_interfacePorts_13_0= rulePort ) )
+                    	    // InternalRoom.g:3033:1: (lv_interfacePorts_13_0= rulePort )
                     	    {
-                    	    // InternalRoom.g:2972:1: (lv_interfacePorts_13_0= rulePort )
-                    	    // InternalRoom.g:2973:3: lv_interfacePorts_13_0= rulePort
+                    	    // InternalRoom.g:3033:1: (lv_interfacePorts_13_0= rulePort )
+                    	    // InternalRoom.g:3034:3: lv_interfacePorts_13_0= rulePort
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getInterfacePortsPortParserRuleCall_7_2_1_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_73);
+                    	    pushFollow(FOLLOW_74);
                     	    lv_interfacePorts_13_0=rulePort();
 
                     	    state._fsp--;
@@ -7439,11 +7613,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop70;
+                    	    break loop72;
                         }
                     } while (true);
 
-                    otherlv_14=(Token)match(input,15,FOLLOW_74); 
+                    otherlv_14=(Token)match(input,15,FOLLOW_75); 
 
                         	newLeafNode(otherlv_14, grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_7_3());
                         
@@ -7453,34 +7627,34 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:2993:3: (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )?
-            int alt77=2;
-            int LA77_0 = input.LA(1);
+            // InternalRoom.g:3054:3: (otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}' )?
+            int alt79=2;
+            int LA79_0 = input.LA(1);
 
-            if ( (LA77_0==57) ) {
-                alt77=1;
+            if ( (LA79_0==57) ) {
+                alt79=1;
             }
-            switch (alt77) {
+            switch (alt79) {
                 case 1 :
-                    // InternalRoom.g:2993:5: otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}'
+                    // InternalRoom.g:3054:5: otherlv_15= 'Structure' ( (lv_structureDocu_16_0= ruleDocumentation ) )? otherlv_17= '{' (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )? (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )? (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )? ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )* otherlv_32= '}'
                     {
                     otherlv_15=(Token)match(input,57,FOLLOW_4); 
 
                         	newLeafNode(otherlv_15, grammarAccess.getActorClassAccess().getStructureKeyword_8_0());
                         
-                    // InternalRoom.g:2997:1: ( (lv_structureDocu_16_0= ruleDocumentation ) )?
-                    int alt72=2;
-                    int LA72_0 = input.LA(1);
+                    // InternalRoom.g:3058:1: ( (lv_structureDocu_16_0= ruleDocumentation ) )?
+                    int alt74=2;
+                    int LA74_0 = input.LA(1);
 
-                    if ( (LA72_0==34) ) {
-                        alt72=1;
+                    if ( (LA74_0==34) ) {
+                        alt74=1;
                     }
-                    switch (alt72) {
+                    switch (alt74) {
                         case 1 :
-                            // InternalRoom.g:2998:1: (lv_structureDocu_16_0= ruleDocumentation )
+                            // InternalRoom.g:3059:1: (lv_structureDocu_16_0= ruleDocumentation )
                             {
-                            // InternalRoom.g:2998:1: (lv_structureDocu_16_0= ruleDocumentation )
-                            // InternalRoom.g:2999:3: lv_structureDocu_16_0= ruleDocumentation
+                            // InternalRoom.g:3059:1: (lv_structureDocu_16_0= ruleDocumentation )
+                            // InternalRoom.g:3060:3: lv_structureDocu_16_0= ruleDocumentation
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getStructureDocuDocumentationParserRuleCall_8_1_0()); 
@@ -7510,35 +7684,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    otherlv_17=(Token)match(input,14,FOLLOW_75); 
+                    otherlv_17=(Token)match(input,14,FOLLOW_76); 
 
                         	newLeafNode(otherlv_17, grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_8_2());
                         
-                    // InternalRoom.g:3019:1: (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )?
-                    int alt73=2;
-                    int LA73_0 = input.LA(1);
+                    // InternalRoom.g:3080:1: (otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) ) )?
+                    int alt75=2;
+                    int LA75_0 = input.LA(1);
 
-                    if ( (LA73_0==30) ) {
-                        alt73=1;
+                    if ( (LA75_0==30) ) {
+                        alt75=1;
                     }
-                    switch (alt73) {
+                    switch (alt75) {
                         case 1 :
-                            // InternalRoom.g:3019:3: otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) )
+                            // InternalRoom.g:3080:3: otherlv_18= 'usercode1' ( (lv_userCode1_19_0= ruleDetailCode ) )
                             {
-                            otherlv_18=(Token)match(input,30,FOLLOW_76); 
+                            otherlv_18=(Token)match(input,30,FOLLOW_77); 
 
                                 	newLeafNode(otherlv_18, grammarAccess.getActorClassAccess().getUsercode1Keyword_8_3_0());
                                 
-                            // InternalRoom.g:3023:1: ( (lv_userCode1_19_0= ruleDetailCode ) )
-                            // InternalRoom.g:3024:1: (lv_userCode1_19_0= ruleDetailCode )
+                            // InternalRoom.g:3084:1: ( (lv_userCode1_19_0= ruleDetailCode ) )
+                            // InternalRoom.g:3085:1: (lv_userCode1_19_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:3024:1: (lv_userCode1_19_0= ruleDetailCode )
-                            // InternalRoom.g:3025:3: lv_userCode1_19_0= ruleDetailCode
+                            // InternalRoom.g:3085:1: (lv_userCode1_19_0= ruleDetailCode )
+                            // InternalRoom.g:3086:3: lv_userCode1_19_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getUserCode1DetailCodeParserRuleCall_8_3_1_0()); 
                             	    
-                            pushFollow(FOLLOW_77);
+                            pushFollow(FOLLOW_78);
                             lv_userCode1_19_0=ruleDetailCode();
 
                             state._fsp--;
@@ -7566,31 +7740,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:3041:4: (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )?
-                    int alt74=2;
-                    int LA74_0 = input.LA(1);
+                    // InternalRoom.g:3102:4: (otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) ) )?
+                    int alt76=2;
+                    int LA76_0 = input.LA(1);
 
-                    if ( (LA74_0==31) ) {
-                        alt74=1;
+                    if ( (LA76_0==31) ) {
+                        alt76=1;
                     }
-                    switch (alt74) {
+                    switch (alt76) {
                         case 1 :
-                            // InternalRoom.g:3041:6: otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) )
+                            // InternalRoom.g:3102:6: otherlv_20= 'usercode2' ( (lv_userCode2_21_0= ruleDetailCode ) )
                             {
-                            otherlv_20=(Token)match(input,31,FOLLOW_78); 
+                            otherlv_20=(Token)match(input,31,FOLLOW_79); 
 
                                 	newLeafNode(otherlv_20, grammarAccess.getActorClassAccess().getUsercode2Keyword_8_4_0());
                                 
-                            // InternalRoom.g:3045:1: ( (lv_userCode2_21_0= ruleDetailCode ) )
-                            // InternalRoom.g:3046:1: (lv_userCode2_21_0= ruleDetailCode )
+                            // InternalRoom.g:3106:1: ( (lv_userCode2_21_0= ruleDetailCode ) )
+                            // InternalRoom.g:3107:1: (lv_userCode2_21_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:3046:1: (lv_userCode2_21_0= ruleDetailCode )
-                            // InternalRoom.g:3047:3: lv_userCode2_21_0= ruleDetailCode
+                            // InternalRoom.g:3107:1: (lv_userCode2_21_0= ruleDetailCode )
+                            // InternalRoom.g:3108:3: lv_userCode2_21_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getUserCode2DetailCodeParserRuleCall_8_4_1_0()); 
                             	    
-                            pushFollow(FOLLOW_79);
+                            pushFollow(FOLLOW_80);
                             lv_userCode2_21_0=ruleDetailCode();
 
                             state._fsp--;
@@ -7618,31 +7792,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:3063:4: (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )?
-                    int alt75=2;
-                    int LA75_0 = input.LA(1);
+                    // InternalRoom.g:3124:4: (otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) ) )?
+                    int alt77=2;
+                    int LA77_0 = input.LA(1);
 
-                    if ( (LA75_0==32) ) {
-                        alt75=1;
+                    if ( (LA77_0==32) ) {
+                        alt77=1;
                     }
-                    switch (alt75) {
+                    switch (alt77) {
                         case 1 :
-                            // InternalRoom.g:3063:6: otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) )
+                            // InternalRoom.g:3124:6: otherlv_22= 'usercode3' ( (lv_userCode3_23_0= ruleDetailCode ) )
                             {
-                            otherlv_22=(Token)match(input,32,FOLLOW_80); 
+                            otherlv_22=(Token)match(input,32,FOLLOW_81); 
 
                                 	newLeafNode(otherlv_22, grammarAccess.getActorClassAccess().getUsercode3Keyword_8_5_0());
                                 
-                            // InternalRoom.g:3067:1: ( (lv_userCode3_23_0= ruleDetailCode ) )
-                            // InternalRoom.g:3068:1: (lv_userCode3_23_0= ruleDetailCode )
+                            // InternalRoom.g:3128:1: ( (lv_userCode3_23_0= ruleDetailCode ) )
+                            // InternalRoom.g:3129:1: (lv_userCode3_23_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:3068:1: (lv_userCode3_23_0= ruleDetailCode )
-                            // InternalRoom.g:3069:3: lv_userCode3_23_0= ruleDetailCode
+                            // InternalRoom.g:3129:1: (lv_userCode3_23_0= ruleDetailCode )
+                            // InternalRoom.g:3130:3: lv_userCode3_23_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getUserCode3DetailCodeParserRuleCall_8_5_1_0()); 
                             	    
-                            pushFollow(FOLLOW_81);
+                            pushFollow(FOLLOW_82);
                             lv_userCode3_23_0=ruleDetailCode();
 
                             state._fsp--;
@@ -7670,71 +7844,71 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:3085:4: ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )*
-                    loop76:
+                    // InternalRoom.g:3146:4: ( ( (lv_connections_24_0= ruleLayerConnection ) ) | ( (lv_bindings_25_0= ruleBinding ) ) | ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) ) | ( (lv_attributes_27_0= ruleAttribute ) ) | ( (lv_actorRefs_28_0= ruleActorRef ) ) | ( (lv_serviceAccessPoints_29_0= ruleSAP ) ) | ( (lv_internalPorts_30_0= rulePort ) ) | ( (lv_externalPorts_31_0= ruleExternalPort ) ) )*
+                    loop78:
                     do {
-                        int alt76=9;
+                        int alt78=9;
                         switch ( input.LA(1) ) {
                         case 74:
                             {
-                            alt76=1;
+                            alt78=1;
                             }
                             break;
                         case 70:
                             {
-                            alt76=2;
+                            alt78=2;
                             }
                             break;
                         case 63:
                             {
-                            alt76=3;
+                            alt78=3;
                             }
                             break;
                         case 33:
                             {
-                            alt76=4;
+                            alt78=4;
                             }
                             break;
                         case 77:
                         case 111:
                         case 127:
                             {
-                            alt76=5;
+                            alt78=5;
                             }
                             break;
                         case 61:
                             {
-                            alt76=6;
+                            alt78=6;
                             }
                             break;
                         case 47:
                         case 59:
                             {
-                            alt76=7;
+                            alt78=7;
                             }
                             break;
                         case 60:
                             {
-                            alt76=8;
+                            alt78=8;
                             }
                             break;
 
                         }
 
-                        switch (alt76) {
+                        switch (alt78) {
                     	case 1 :
-                    	    // InternalRoom.g:3085:5: ( (lv_connections_24_0= ruleLayerConnection ) )
+                    	    // InternalRoom.g:3146:5: ( (lv_connections_24_0= ruleLayerConnection ) )
                     	    {
-                    	    // InternalRoom.g:3085:5: ( (lv_connections_24_0= ruleLayerConnection ) )
-                    	    // InternalRoom.g:3086:1: (lv_connections_24_0= ruleLayerConnection )
+                    	    // InternalRoom.g:3146:5: ( (lv_connections_24_0= ruleLayerConnection ) )
+                    	    // InternalRoom.g:3147:1: (lv_connections_24_0= ruleLayerConnection )
                     	    {
-                    	    // InternalRoom.g:3086:1: (lv_connections_24_0= ruleLayerConnection )
-                    	    // InternalRoom.g:3087:3: lv_connections_24_0= ruleLayerConnection
+                    	    // InternalRoom.g:3147:1: (lv_connections_24_0= ruleLayerConnection )
+                    	    // InternalRoom.g:3148:3: lv_connections_24_0= ruleLayerConnection
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getConnectionsLayerConnectionParserRuleCall_8_6_0_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_connections_24_0=ruleLayerConnection();
 
                     	    state._fsp--;
@@ -7760,18 +7934,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:3104:6: ( (lv_bindings_25_0= ruleBinding ) )
+                    	    // InternalRoom.g:3165:6: ( (lv_bindings_25_0= ruleBinding ) )
                     	    {
-                    	    // InternalRoom.g:3104:6: ( (lv_bindings_25_0= ruleBinding ) )
-                    	    // InternalRoom.g:3105:1: (lv_bindings_25_0= ruleBinding )
+                    	    // InternalRoom.g:3165:6: ( (lv_bindings_25_0= ruleBinding ) )
+                    	    // InternalRoom.g:3166:1: (lv_bindings_25_0= ruleBinding )
                     	    {
-                    	    // InternalRoom.g:3105:1: (lv_bindings_25_0= ruleBinding )
-                    	    // InternalRoom.g:3106:3: lv_bindings_25_0= ruleBinding
+                    	    // InternalRoom.g:3166:1: (lv_bindings_25_0= ruleBinding )
+                    	    // InternalRoom.g:3167:3: lv_bindings_25_0= ruleBinding
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getBindingsBindingParserRuleCall_8_6_1_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_bindings_25_0=ruleBinding();
 
                     	    state._fsp--;
@@ -7797,18 +7971,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 3 :
-                    	    // InternalRoom.g:3123:6: ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) )
+                    	    // InternalRoom.g:3184:6: ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) )
                     	    {
-                    	    // InternalRoom.g:3123:6: ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) )
-                    	    // InternalRoom.g:3124:1: (lv_serviceImplementations_26_0= ruleServiceImplementation )
+                    	    // InternalRoom.g:3184:6: ( (lv_serviceImplementations_26_0= ruleServiceImplementation ) )
+                    	    // InternalRoom.g:3185:1: (lv_serviceImplementations_26_0= ruleServiceImplementation )
                     	    {
-                    	    // InternalRoom.g:3124:1: (lv_serviceImplementations_26_0= ruleServiceImplementation )
-                    	    // InternalRoom.g:3125:3: lv_serviceImplementations_26_0= ruleServiceImplementation
+                    	    // InternalRoom.g:3185:1: (lv_serviceImplementations_26_0= ruleServiceImplementation )
+                    	    // InternalRoom.g:3186:3: lv_serviceImplementations_26_0= ruleServiceImplementation
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getServiceImplementationsServiceImplementationParserRuleCall_8_6_2_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_serviceImplementations_26_0=ruleServiceImplementation();
 
                     	    state._fsp--;
@@ -7834,18 +8008,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 4 :
-                    	    // InternalRoom.g:3142:6: ( (lv_attributes_27_0= ruleAttribute ) )
+                    	    // InternalRoom.g:3203:6: ( (lv_attributes_27_0= ruleAttribute ) )
                     	    {
-                    	    // InternalRoom.g:3142:6: ( (lv_attributes_27_0= ruleAttribute ) )
-                    	    // InternalRoom.g:3143:1: (lv_attributes_27_0= ruleAttribute )
+                    	    // InternalRoom.g:3203:6: ( (lv_attributes_27_0= ruleAttribute ) )
+                    	    // InternalRoom.g:3204:1: (lv_attributes_27_0= ruleAttribute )
                     	    {
-                    	    // InternalRoom.g:3143:1: (lv_attributes_27_0= ruleAttribute )
-                    	    // InternalRoom.g:3144:3: lv_attributes_27_0= ruleAttribute
+                    	    // InternalRoom.g:3204:1: (lv_attributes_27_0= ruleAttribute )
+                    	    // InternalRoom.g:3205:3: lv_attributes_27_0= ruleAttribute
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getAttributesAttributeParserRuleCall_8_6_3_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_attributes_27_0=ruleAttribute();
 
                     	    state._fsp--;
@@ -7871,18 +8045,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 5 :
-                    	    // InternalRoom.g:3161:6: ( (lv_actorRefs_28_0= ruleActorRef ) )
+                    	    // InternalRoom.g:3222:6: ( (lv_actorRefs_28_0= ruleActorRef ) )
                     	    {
-                    	    // InternalRoom.g:3161:6: ( (lv_actorRefs_28_0= ruleActorRef ) )
-                    	    // InternalRoom.g:3162:1: (lv_actorRefs_28_0= ruleActorRef )
+                    	    // InternalRoom.g:3222:6: ( (lv_actorRefs_28_0= ruleActorRef ) )
+                    	    // InternalRoom.g:3223:1: (lv_actorRefs_28_0= ruleActorRef )
                     	    {
-                    	    // InternalRoom.g:3162:1: (lv_actorRefs_28_0= ruleActorRef )
-                    	    // InternalRoom.g:3163:3: lv_actorRefs_28_0= ruleActorRef
+                    	    // InternalRoom.g:3223:1: (lv_actorRefs_28_0= ruleActorRef )
+                    	    // InternalRoom.g:3224:3: lv_actorRefs_28_0= ruleActorRef
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getActorRefsActorRefParserRuleCall_8_6_4_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_actorRefs_28_0=ruleActorRef();
 
                     	    state._fsp--;
@@ -7908,18 +8082,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 6 :
-                    	    // InternalRoom.g:3180:6: ( (lv_serviceAccessPoints_29_0= ruleSAP ) )
+                    	    // InternalRoom.g:3241:6: ( (lv_serviceAccessPoints_29_0= ruleSAP ) )
                     	    {
-                    	    // InternalRoom.g:3180:6: ( (lv_serviceAccessPoints_29_0= ruleSAP ) )
-                    	    // InternalRoom.g:3181:1: (lv_serviceAccessPoints_29_0= ruleSAP )
+                    	    // InternalRoom.g:3241:6: ( (lv_serviceAccessPoints_29_0= ruleSAP ) )
+                    	    // InternalRoom.g:3242:1: (lv_serviceAccessPoints_29_0= ruleSAP )
                     	    {
-                    	    // InternalRoom.g:3181:1: (lv_serviceAccessPoints_29_0= ruleSAP )
-                    	    // InternalRoom.g:3182:3: lv_serviceAccessPoints_29_0= ruleSAP
+                    	    // InternalRoom.g:3242:1: (lv_serviceAccessPoints_29_0= ruleSAP )
+                    	    // InternalRoom.g:3243:3: lv_serviceAccessPoints_29_0= ruleSAP
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getServiceAccessPointsSAPParserRuleCall_8_6_5_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_serviceAccessPoints_29_0=ruleSAP();
 
                     	    state._fsp--;
@@ -7945,18 +8119,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 7 :
-                    	    // InternalRoom.g:3199:6: ( (lv_internalPorts_30_0= rulePort ) )
+                    	    // InternalRoom.g:3260:6: ( (lv_internalPorts_30_0= rulePort ) )
                     	    {
-                    	    // InternalRoom.g:3199:6: ( (lv_internalPorts_30_0= rulePort ) )
-                    	    // InternalRoom.g:3200:1: (lv_internalPorts_30_0= rulePort )
+                    	    // InternalRoom.g:3260:6: ( (lv_internalPorts_30_0= rulePort ) )
+                    	    // InternalRoom.g:3261:1: (lv_internalPorts_30_0= rulePort )
                     	    {
-                    	    // InternalRoom.g:3200:1: (lv_internalPorts_30_0= rulePort )
-                    	    // InternalRoom.g:3201:3: lv_internalPorts_30_0= rulePort
+                    	    // InternalRoom.g:3261:1: (lv_internalPorts_30_0= rulePort )
+                    	    // InternalRoom.g:3262:3: lv_internalPorts_30_0= rulePort
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getInternalPortsPortParserRuleCall_8_6_6_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_internalPorts_30_0=rulePort();
 
                     	    state._fsp--;
@@ -7982,18 +8156,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 8 :
-                    	    // InternalRoom.g:3218:6: ( (lv_externalPorts_31_0= ruleExternalPort ) )
+                    	    // InternalRoom.g:3279:6: ( (lv_externalPorts_31_0= ruleExternalPort ) )
                     	    {
-                    	    // InternalRoom.g:3218:6: ( (lv_externalPorts_31_0= ruleExternalPort ) )
-                    	    // InternalRoom.g:3219:1: (lv_externalPorts_31_0= ruleExternalPort )
+                    	    // InternalRoom.g:3279:6: ( (lv_externalPorts_31_0= ruleExternalPort ) )
+                    	    // InternalRoom.g:3280:1: (lv_externalPorts_31_0= ruleExternalPort )
                     	    {
-                    	    // InternalRoom.g:3219:1: (lv_externalPorts_31_0= ruleExternalPort )
-                    	    // InternalRoom.g:3220:3: lv_externalPorts_31_0= ruleExternalPort
+                    	    // InternalRoom.g:3280:1: (lv_externalPorts_31_0= ruleExternalPort )
+                    	    // InternalRoom.g:3281:3: lv_externalPorts_31_0= ruleExternalPort
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getExternalPortsExternalPortParserRuleCall_8_6_7_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_81);
+                    	    pushFollow(FOLLOW_82);
                     	    lv_externalPorts_31_0=ruleExternalPort();
 
                     	    state._fsp--;
@@ -8020,11 +8194,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop76;
+                    	    break loop78;
                         }
                     } while (true);
 
-                    otherlv_32=(Token)match(input,15,FOLLOW_82); 
+                    otherlv_32=(Token)match(input,15,FOLLOW_83); 
 
                         	newLeafNode(otherlv_32, grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_8_7());
                         
@@ -8034,34 +8208,34 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:3240:3: (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )?
-            int alt82=2;
-            int LA82_0 = input.LA(1);
+            // InternalRoom.g:3301:3: (otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}' )?
+            int alt84=2;
+            int LA84_0 = input.LA(1);
 
-            if ( (LA82_0==58) ) {
-                alt82=1;
+            if ( (LA84_0==58) ) {
+                alt84=1;
             }
-            switch (alt82) {
+            switch (alt84) {
                 case 1 :
-                    // InternalRoom.g:3240:5: otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}'
+                    // InternalRoom.g:3301:5: otherlv_33= 'Behavior' ( (lv_behaviorDocu_34_0= ruleDocumentation ) )? otherlv_35= '{' ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )* ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )* ( (lv_stateMachine_39_0= ruleStateMachine ) )? otherlv_40= '}'
                     {
                     otherlv_33=(Token)match(input,58,FOLLOW_4); 
 
                         	newLeafNode(otherlv_33, grammarAccess.getActorClassAccess().getBehaviorKeyword_9_0());
                         
-                    // InternalRoom.g:3244:1: ( (lv_behaviorDocu_34_0= ruleDocumentation ) )?
-                    int alt78=2;
-                    int LA78_0 = input.LA(1);
+                    // InternalRoom.g:3305:1: ( (lv_behaviorDocu_34_0= ruleDocumentation ) )?
+                    int alt80=2;
+                    int LA80_0 = input.LA(1);
 
-                    if ( (LA78_0==34) ) {
-                        alt78=1;
+                    if ( (LA80_0==34) ) {
+                        alt80=1;
                     }
-                    switch (alt78) {
+                    switch (alt80) {
                         case 1 :
-                            // InternalRoom.g:3245:1: (lv_behaviorDocu_34_0= ruleDocumentation )
+                            // InternalRoom.g:3306:1: (lv_behaviorDocu_34_0= ruleDocumentation )
                             {
-                            // InternalRoom.g:3245:1: (lv_behaviorDocu_34_0= ruleDocumentation )
-                            // InternalRoom.g:3246:3: lv_behaviorDocu_34_0= ruleDocumentation
+                            // InternalRoom.g:3306:1: (lv_behaviorDocu_34_0= ruleDocumentation )
+                            // InternalRoom.g:3307:3: lv_behaviorDocu_34_0= ruleDocumentation
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getBehaviorDocuDocumentationParserRuleCall_9_1_0()); 
@@ -8091,32 +8265,32 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    otherlv_35=(Token)match(input,14,FOLLOW_83); 
+                    otherlv_35=(Token)match(input,14,FOLLOW_84); 
 
                         	newLeafNode(otherlv_35, grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_9_2());
                         
-                    // InternalRoom.g:3266:1: ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )*
-                    loop79:
+                    // InternalRoom.g:3327:1: ( (lv_behaviorAnnotations_36_0= ruleAnnotation ) )*
+                    loop81:
                     do {
-                        int alt79=2;
-                        int LA79_0 = input.LA(1);
+                        int alt81=2;
+                        int LA81_0 = input.LA(1);
 
-                        if ( (LA79_0==108) ) {
-                            alt79=1;
+                        if ( (LA81_0==108) ) {
+                            alt81=1;
                         }
 
 
-                        switch (alt79) {
+                        switch (alt81) {
                     	case 1 :
-                    	    // InternalRoom.g:3267:1: (lv_behaviorAnnotations_36_0= ruleAnnotation )
+                    	    // InternalRoom.g:3328:1: (lv_behaviorAnnotations_36_0= ruleAnnotation )
                     	    {
-                    	    // InternalRoom.g:3267:1: (lv_behaviorAnnotations_36_0= ruleAnnotation )
-                    	    // InternalRoom.g:3268:3: lv_behaviorAnnotations_36_0= ruleAnnotation
+                    	    // InternalRoom.g:3328:1: (lv_behaviorAnnotations_36_0= ruleAnnotation )
+                    	    // InternalRoom.g:3329:3: lv_behaviorAnnotations_36_0= ruleAnnotation
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAnnotationParserRuleCall_9_3_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_83);
+                    	    pushFollow(FOLLOW_84);
                     	    lv_behaviorAnnotations_36_0=ruleAnnotation();
 
                     	    state._fsp--;
@@ -8140,38 +8314,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop79;
+                    	    break loop81;
                         }
                     } while (true);
 
-                    // InternalRoom.g:3284:3: ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )*
-                    loop80:
+                    // InternalRoom.g:3345:3: ( ( (lv_operations_37_0= ruleStandardOperation ) ) | ( (lv_structors_38_0= ruleClassStructor ) ) )*
+                    loop82:
                     do {
-                        int alt80=3;
-                        int LA80_0 = input.LA(1);
+                        int alt82=3;
+                        int LA82_0 = input.LA(1);
 
-                        if ( ((LA80_0>=36 && LA80_0<=37)) ) {
-                            alt80=1;
+                        if ( ((LA82_0>=36 && LA82_0<=37)) ) {
+                            alt82=1;
                         }
-                        else if ( ((LA80_0>=40 && LA80_0<=41)) ) {
-                            alt80=2;
+                        else if ( ((LA82_0>=40 && LA82_0<=41)) ) {
+                            alt82=2;
                         }
 
 
-                        switch (alt80) {
+                        switch (alt82) {
                     	case 1 :
-                    	    // InternalRoom.g:3284:4: ( (lv_operations_37_0= ruleStandardOperation ) )
+                    	    // InternalRoom.g:3345:4: ( (lv_operations_37_0= ruleStandardOperation ) )
                     	    {
-                    	    // InternalRoom.g:3284:4: ( (lv_operations_37_0= ruleStandardOperation ) )
-                    	    // InternalRoom.g:3285:1: (lv_operations_37_0= ruleStandardOperation )
+                    	    // InternalRoom.g:3345:4: ( (lv_operations_37_0= ruleStandardOperation ) )
+                    	    // InternalRoom.g:3346:1: (lv_operations_37_0= ruleStandardOperation )
                     	    {
-                    	    // InternalRoom.g:3285:1: (lv_operations_37_0= ruleStandardOperation )
-                    	    // InternalRoom.g:3286:3: lv_operations_37_0= ruleStandardOperation
+                    	    // InternalRoom.g:3346:1: (lv_operations_37_0= ruleStandardOperation )
+                    	    // InternalRoom.g:3347:3: lv_operations_37_0= ruleStandardOperation
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getOperationsStandardOperationParserRuleCall_9_4_0_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_84);
+                    	    pushFollow(FOLLOW_85);
                     	    lv_operations_37_0=ruleStandardOperation();
 
                     	    state._fsp--;
@@ -8197,18 +8371,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:3303:6: ( (lv_structors_38_0= ruleClassStructor ) )
+                    	    // InternalRoom.g:3364:6: ( (lv_structors_38_0= ruleClassStructor ) )
                     	    {
-                    	    // InternalRoom.g:3303:6: ( (lv_structors_38_0= ruleClassStructor ) )
-                    	    // InternalRoom.g:3304:1: (lv_structors_38_0= ruleClassStructor )
+                    	    // InternalRoom.g:3364:6: ( (lv_structors_38_0= ruleClassStructor ) )
+                    	    // InternalRoom.g:3365:1: (lv_structors_38_0= ruleClassStructor )
                     	    {
-                    	    // InternalRoom.g:3304:1: (lv_structors_38_0= ruleClassStructor )
-                    	    // InternalRoom.g:3305:3: lv_structors_38_0= ruleClassStructor
+                    	    // InternalRoom.g:3365:1: (lv_structors_38_0= ruleClassStructor )
+                    	    // InternalRoom.g:3366:3: lv_structors_38_0= ruleClassStructor
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorClassAccess().getStructorsClassStructorParserRuleCall_9_4_1_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_84);
+                    	    pushFollow(FOLLOW_85);
                     	    lv_structors_38_0=ruleClassStructor();
 
                     	    state._fsp--;
@@ -8235,23 +8409,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop80;
+                    	    break loop82;
                         }
                     } while (true);
 
-                    // InternalRoom.g:3321:4: ( (lv_stateMachine_39_0= ruleStateMachine ) )?
-                    int alt81=2;
-                    int LA81_0 = input.LA(1);
+                    // InternalRoom.g:3382:4: ( (lv_stateMachine_39_0= ruleStateMachine ) )?
+                    int alt83=2;
+                    int LA83_0 = input.LA(1);
 
-                    if ( (LA81_0==80) ) {
-                        alt81=1;
+                    if ( (LA83_0==80) ) {
+                        alt83=1;
                     }
-                    switch (alt81) {
+                    switch (alt83) {
                         case 1 :
-                            // InternalRoom.g:3322:1: (lv_stateMachine_39_0= ruleStateMachine )
+                            // InternalRoom.g:3383:1: (lv_stateMachine_39_0= ruleStateMachine )
                             {
-                            // InternalRoom.g:3322:1: (lv_stateMachine_39_0= ruleStateMachine )
-                            // InternalRoom.g:3323:3: lv_stateMachine_39_0= ruleStateMachine
+                            // InternalRoom.g:3383:1: (lv_stateMachine_39_0= ruleStateMachine )
+                            // InternalRoom.g:3384:3: lv_stateMachine_39_0= ruleStateMachine
                             {
                              
                             	        newCompositeNode(grammarAccess.getActorClassAccess().getStateMachineStateMachineParserRuleCall_9_5_0()); 
@@ -8316,7 +8490,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInterfaceItem"
-    // InternalRoom.g:3355:1: entryRuleInterfaceItem returns [EObject current=null] : iv_ruleInterfaceItem= ruleInterfaceItem EOF ;
+    // InternalRoom.g:3416:1: entryRuleInterfaceItem returns [EObject current=null] : iv_ruleInterfaceItem= ruleInterfaceItem EOF ;
     public final EObject entryRuleInterfaceItem() throws RecognitionException {
         EObject current = null;
 
@@ -8324,8 +8498,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3356:2: (iv_ruleInterfaceItem= ruleInterfaceItem EOF )
-            // InternalRoom.g:3357:2: iv_ruleInterfaceItem= ruleInterfaceItem EOF
+            // InternalRoom.g:3417:2: (iv_ruleInterfaceItem= ruleInterfaceItem EOF )
+            // InternalRoom.g:3418:2: iv_ruleInterfaceItem= ruleInterfaceItem EOF
             {
              newCompositeNode(grammarAccess.getInterfaceItemRule()); 
             pushFollow(FOLLOW_1);
@@ -8352,7 +8526,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInterfaceItem"
-    // InternalRoom.g:3364:1: ruleInterfaceItem returns [EObject current=null] : (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP ) ;
+    // InternalRoom.g:3425:1: ruleInterfaceItem returns [EObject current=null] : (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP ) ;
     public final EObject ruleInterfaceItem() throws RecognitionException {
         EObject current = null;
 
@@ -8366,38 +8540,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3367:28: ( (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP ) )
-            // InternalRoom.g:3368:1: (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP )
+            // InternalRoom.g:3428:28: ( (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP ) )
+            // InternalRoom.g:3429:1: (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP )
             {
-            // InternalRoom.g:3368:1: (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP )
-            int alt83=3;
+            // InternalRoom.g:3429:1: (this_Port_0= rulePort | this_SAP_1= ruleSAP | this_SPP_2= ruleSPP )
+            int alt85=3;
             switch ( input.LA(1) ) {
             case 47:
             case 59:
                 {
-                alt83=1;
+                alt85=1;
                 }
                 break;
             case 61:
                 {
-                alt83=2;
+                alt85=2;
                 }
                 break;
             case 62:
                 {
-                alt83=3;
+                alt85=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 83, 0, input);
+                    new NoViableAltException("", 85, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt83) {
+            switch (alt85) {
                 case 1 :
-                    // InternalRoom.g:3369:5: this_Port_0= rulePort
+                    // InternalRoom.g:3430:5: this_Port_0= rulePort
                     {
                      
                             newCompositeNode(grammarAccess.getInterfaceItemAccess().getPortParserRuleCall_0()); 
@@ -8415,7 +8589,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3379:5: this_SAP_1= ruleSAP
+                    // InternalRoom.g:3440:5: this_SAP_1= ruleSAP
                     {
                      
                             newCompositeNode(grammarAccess.getInterfaceItemAccess().getSAPParserRuleCall_1()); 
@@ -8433,7 +8607,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3389:5: this_SPP_2= ruleSPP
+                    // InternalRoom.g:3450:5: this_SPP_2= ruleSPP
                     {
                      
                             newCompositeNode(grammarAccess.getInterfaceItemAccess().getSPPParserRuleCall_2()); 
@@ -8471,7 +8645,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRulePort"
-    // InternalRoom.g:3405:1: entryRulePort returns [EObject current=null] : iv_rulePort= rulePort EOF ;
+    // InternalRoom.g:3466:1: entryRulePort returns [EObject current=null] : iv_rulePort= rulePort EOF ;
     public final EObject entryRulePort() throws RecognitionException {
         EObject current = null;
 
@@ -8479,8 +8653,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3406:2: (iv_rulePort= rulePort EOF )
-            // InternalRoom.g:3407:2: iv_rulePort= rulePort EOF
+            // InternalRoom.g:3467:2: (iv_rulePort= rulePort EOF )
+            // InternalRoom.g:3468:2: iv_rulePort= rulePort EOF
             {
              newCompositeNode(grammarAccess.getPortRule()); 
             pushFollow(FOLLOW_1);
@@ -8507,7 +8681,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "rulePort"
-    // InternalRoom.g:3414:1: rulePort returns [EObject current=null] : ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:3475:1: rulePort returns [EObject current=null] : ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) ;
     public final EObject rulePort() throws RecognitionException {
         EObject current = null;
 
@@ -8525,27 +8699,27 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3417:28: ( ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:3418:1: ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
+            // InternalRoom.g:3478:28: ( ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:3479:1: ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:3418:1: ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
-            // InternalRoom.g:3418:2: ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )?
+            // InternalRoom.g:3479:1: ( ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )? )
+            // InternalRoom.g:3479:2: ( (lv_conjugated_0_0= 'conjugated' ) )? otherlv_1= 'Port' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_annotations_6_0= ruleAnnotation ) )* ( (lv_docu_7_0= ruleDocumentation ) )?
             {
-            // InternalRoom.g:3418:2: ( (lv_conjugated_0_0= 'conjugated' ) )?
-            int alt84=2;
-            int LA84_0 = input.LA(1);
+            // InternalRoom.g:3479:2: ( (lv_conjugated_0_0= 'conjugated' ) )?
+            int alt86=2;
+            int LA86_0 = input.LA(1);
 
-            if ( (LA84_0==47) ) {
-                alt84=1;
+            if ( (LA86_0==47) ) {
+                alt86=1;
             }
-            switch (alt84) {
+            switch (alt86) {
                 case 1 :
-                    // InternalRoom.g:3419:1: (lv_conjugated_0_0= 'conjugated' )
+                    // InternalRoom.g:3480:1: (lv_conjugated_0_0= 'conjugated' )
                     {
-                    // InternalRoom.g:3419:1: (lv_conjugated_0_0= 'conjugated' )
-                    // InternalRoom.g:3420:3: lv_conjugated_0_0= 'conjugated'
+                    // InternalRoom.g:3480:1: (lv_conjugated_0_0= 'conjugated' )
+                    // InternalRoom.g:3481:3: lv_conjugated_0_0= 'conjugated'
                     {
-                    lv_conjugated_0_0=(Token)match(input,47,FOLLOW_85); 
+                    lv_conjugated_0_0=(Token)match(input,47,FOLLOW_86); 
 
                             newLeafNode(lv_conjugated_0_0, grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0());
                         
@@ -8568,11 +8742,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getPortAccess().getPortKeyword_1());
                 
-            // InternalRoom.g:3437:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:3438:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:3498:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:3499:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:3438:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:3439:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:3499:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:3500:3: lv_name_2_0= RULE_ID
             {
             lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_33); 
 
@@ -8594,19 +8768,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:3455:2: ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )?
-            int alt85=2;
-            int LA85_0 = input.LA(1);
+            // InternalRoom.g:3516:2: ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )?
+            int alt87=2;
+            int LA87_0 = input.LA(1);
 
-            if ( (LA85_0==34) ) {
-                alt85=1;
+            if ( (LA87_0==34) ) {
+                alt87=1;
             }
-            switch (alt85) {
+            switch (alt87) {
                 case 1 :
-                    // InternalRoom.g:3456:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
+                    // InternalRoom.g:3517:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
                     {
-                    // InternalRoom.g:3456:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
-                    // InternalRoom.g:3457:3: lv_multiplicity_3_0= ruleMULTIPLICITY
+                    // InternalRoom.g:3517:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
+                    // InternalRoom.g:3518:3: lv_multiplicity_3_0= ruleMULTIPLICITY
                     {
                      
                     	        newCompositeNode(grammarAccess.getPortAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
@@ -8640,11 +8814,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getPortAccess().getColonKeyword_4());
                 
-            // InternalRoom.g:3477:1: ( ( ruleFQN ) )
-            // InternalRoom.g:3478:1: ( ruleFQN )
+            // InternalRoom.g:3538:1: ( ( ruleFQN ) )
+            // InternalRoom.g:3539:1: ( ruleFQN )
             {
-            // InternalRoom.g:3478:1: ( ruleFQN )
-            // InternalRoom.g:3479:3: ruleFQN
+            // InternalRoom.g:3539:1: ( ruleFQN )
+            // InternalRoom.g:3540:3: ruleFQN
             {
 
             			if (current==null) {
@@ -8654,7 +8828,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
             	        newCompositeNode(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassCrossReference_5_0()); 
             	    
-            pushFollow(FOLLOW_65);
+            pushFollow(FOLLOW_66);
             ruleFQN();
 
             state._fsp--;
@@ -8668,28 +8842,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:3492:2: ( (lv_annotations_6_0= ruleAnnotation ) )*
-            loop86:
+            // InternalRoom.g:3553:2: ( (lv_annotations_6_0= ruleAnnotation ) )*
+            loop88:
             do {
-                int alt86=2;
-                int LA86_0 = input.LA(1);
+                int alt88=2;
+                int LA88_0 = input.LA(1);
 
-                if ( (LA86_0==108) ) {
-                    alt86=1;
+                if ( (LA88_0==108) ) {
+                    alt88=1;
                 }
 
 
-                switch (alt86) {
+                switch (alt88) {
             	case 1 :
-            	    // InternalRoom.g:3493:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:3554:1: (lv_annotations_6_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:3493:1: (lv_annotations_6_0= ruleAnnotation )
-            	    // InternalRoom.g:3494:3: lv_annotations_6_0= ruleAnnotation
+            	    // InternalRoom.g:3554:1: (lv_annotations_6_0= ruleAnnotation )
+            	    // InternalRoom.g:3555:3: lv_annotations_6_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getPortAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             	    	    
-            	    pushFollow(FOLLOW_65);
+            	    pushFollow(FOLLOW_66);
             	    lv_annotations_6_0=ruleAnnotation();
 
             	    state._fsp--;
@@ -8713,23 +8887,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop86;
+            	    break loop88;
                 }
             } while (true);
 
-            // InternalRoom.g:3510:3: ( (lv_docu_7_0= ruleDocumentation ) )?
-            int alt87=2;
-            int LA87_0 = input.LA(1);
+            // InternalRoom.g:3571:3: ( (lv_docu_7_0= ruleDocumentation ) )?
+            int alt89=2;
+            int LA89_0 = input.LA(1);
 
-            if ( (LA87_0==34) ) {
-                alt87=1;
+            if ( (LA89_0==34) ) {
+                alt89=1;
             }
-            switch (alt87) {
+            switch (alt89) {
                 case 1 :
-                    // InternalRoom.g:3511:1: (lv_docu_7_0= ruleDocumentation )
+                    // InternalRoom.g:3572:1: (lv_docu_7_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:3511:1: (lv_docu_7_0= ruleDocumentation )
-                    // InternalRoom.g:3512:3: lv_docu_7_0= ruleDocumentation
+                    // InternalRoom.g:3572:1: (lv_docu_7_0= ruleDocumentation )
+                    // InternalRoom.g:3573:3: lv_docu_7_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getPortAccess().getDocuDocumentationParserRuleCall_7_0()); 
@@ -8780,7 +8954,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleExternalPort"
-    // InternalRoom.g:3536:1: entryRuleExternalPort returns [EObject current=null] : iv_ruleExternalPort= ruleExternalPort EOF ;
+    // InternalRoom.g:3597:1: entryRuleExternalPort returns [EObject current=null] : iv_ruleExternalPort= ruleExternalPort EOF ;
     public final EObject entryRuleExternalPort() throws RecognitionException {
         EObject current = null;
 
@@ -8788,8 +8962,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3537:2: (iv_ruleExternalPort= ruleExternalPort EOF )
-            // InternalRoom.g:3538:2: iv_ruleExternalPort= ruleExternalPort EOF
+            // InternalRoom.g:3598:2: (iv_ruleExternalPort= ruleExternalPort EOF )
+            // InternalRoom.g:3599:2: iv_ruleExternalPort= ruleExternalPort EOF
             {
              newCompositeNode(grammarAccess.getExternalPortRule()); 
             pushFollow(FOLLOW_1);
@@ -8816,7 +8990,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleExternalPort"
-    // InternalRoom.g:3545:1: ruleExternalPort returns [EObject current=null] : (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalRoom.g:3606:1: ruleExternalPort returns [EObject current=null] : (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleExternalPort() throws RecognitionException {
         EObject current = null;
 
@@ -8827,13 +9001,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3548:28: ( (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalRoom.g:3549:1: (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:3609:28: ( (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:3610:1: (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalRoom.g:3549:1: (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) )
-            // InternalRoom.g:3549:3: otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:3610:1: (otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:3610:3: otherlv_0= 'external' otherlv_1= 'Port' ( (otherlv_2= RULE_ID ) )
             {
-            otherlv_0=(Token)match(input,60,FOLLOW_85); 
+            otherlv_0=(Token)match(input,60,FOLLOW_86); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getExternalPortAccess().getExternalKeyword_0());
                 
@@ -8841,11 +9015,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getExternalPortAccess().getPortKeyword_1());
                 
-            // InternalRoom.g:3557:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:3558:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:3618:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:3619:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:3558:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:3559:3: otherlv_2= RULE_ID
+            // InternalRoom.g:3619:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:3620:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -8883,7 +9057,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSAP"
-    // InternalRoom.g:3578:1: entryRuleSAP returns [EObject current=null] : iv_ruleSAP= ruleSAP EOF ;
+    // InternalRoom.g:3639:1: entryRuleSAP returns [EObject current=null] : iv_ruleSAP= ruleSAP EOF ;
     public final EObject entryRuleSAP() throws RecognitionException {
         EObject current = null;
 
@@ -8891,8 +9065,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3579:2: (iv_ruleSAP= ruleSAP EOF )
-            // InternalRoom.g:3580:2: iv_ruleSAP= ruleSAP EOF
+            // InternalRoom.g:3640:2: (iv_ruleSAP= ruleSAP EOF )
+            // InternalRoom.g:3641:2: iv_ruleSAP= ruleSAP EOF
             {
              newCompositeNode(grammarAccess.getSAPRule()); 
             pushFollow(FOLLOW_1);
@@ -8919,7 +9093,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSAP"
-    // InternalRoom.g:3587:1: ruleSAP returns [EObject current=null] : (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
+    // InternalRoom.g:3648:1: ruleSAP returns [EObject current=null] : (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
     public final EObject ruleSAP() throws RecognitionException {
         EObject current = null;
 
@@ -8930,21 +9104,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3590:28: ( (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
-            // InternalRoom.g:3591:1: (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:3651:28: ( (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
+            // InternalRoom.g:3652:1: (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
             {
-            // InternalRoom.g:3591:1: (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
-            // InternalRoom.g:3591:3: otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
+            // InternalRoom.g:3652:1: (otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:3652:3: otherlv_0= 'SAP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
             {
             otherlv_0=(Token)match(input,61,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSAPAccess().getSAPKeyword_0());
                 
-            // InternalRoom.g:3595:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:3596:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3656:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:3657:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:3596:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:3597:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:3657:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3658:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -8970,11 +9144,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSAPAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:3617:1: ( ( ruleFQN ) )
-            // InternalRoom.g:3618:1: ( ruleFQN )
+            // InternalRoom.g:3678:1: ( ( ruleFQN ) )
+            // InternalRoom.g:3679:1: ( ruleFQN )
             {
-            // InternalRoom.g:3618:1: ( ruleFQN )
-            // InternalRoom.g:3619:3: ruleFQN
+            // InternalRoom.g:3679:1: ( ruleFQN )
+            // InternalRoom.g:3680:3: ruleFQN
             {
 
             			if (current==null) {
@@ -9019,7 +9193,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSPP"
-    // InternalRoom.g:3640:1: entryRuleSPP returns [EObject current=null] : iv_ruleSPP= ruleSPP EOF ;
+    // InternalRoom.g:3701:1: entryRuleSPP returns [EObject current=null] : iv_ruleSPP= ruleSPP EOF ;
     public final EObject entryRuleSPP() throws RecognitionException {
         EObject current = null;
 
@@ -9027,8 +9201,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3641:2: (iv_ruleSPP= ruleSPP EOF )
-            // InternalRoom.g:3642:2: iv_ruleSPP= ruleSPP EOF
+            // InternalRoom.g:3702:2: (iv_ruleSPP= ruleSPP EOF )
+            // InternalRoom.g:3703:2: iv_ruleSPP= ruleSPP EOF
             {
              newCompositeNode(grammarAccess.getSPPRule()); 
             pushFollow(FOLLOW_1);
@@ -9055,7 +9229,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSPP"
-    // InternalRoom.g:3649:1: ruleSPP returns [EObject current=null] : (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
+    // InternalRoom.g:3710:1: ruleSPP returns [EObject current=null] : (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) ;
     public final EObject ruleSPP() throws RecognitionException {
         EObject current = null;
 
@@ -9066,21 +9240,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3652:28: ( (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
-            // InternalRoom.g:3653:1: (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:3713:28: ( (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ) )
+            // InternalRoom.g:3714:1: (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
             {
-            // InternalRoom.g:3653:1: (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
-            // InternalRoom.g:3653:3: otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
+            // InternalRoom.g:3714:1: (otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) )
+            // InternalRoom.g:3714:3: otherlv_0= 'SPP' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) )
             {
             otherlv_0=(Token)match(input,62,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSPPAccess().getSPPKeyword_0());
                 
-            // InternalRoom.g:3657:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:3658:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3718:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:3719:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:3658:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:3659:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:3719:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3720:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -9106,11 +9280,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSPPAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:3679:1: ( ( ruleFQN ) )
-            // InternalRoom.g:3680:1: ( ruleFQN )
+            // InternalRoom.g:3740:1: ( ( ruleFQN ) )
+            // InternalRoom.g:3741:1: ( ruleFQN )
             {
-            // InternalRoom.g:3680:1: ( ruleFQN )
-            // InternalRoom.g:3681:3: ruleFQN
+            // InternalRoom.g:3741:1: ( ruleFQN )
+            // InternalRoom.g:3742:3: ruleFQN
             {
 
             			if (current==null) {
@@ -9155,7 +9329,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleServiceImplementation"
-    // InternalRoom.g:3702:1: entryRuleServiceImplementation returns [EObject current=null] : iv_ruleServiceImplementation= ruleServiceImplementation EOF ;
+    // InternalRoom.g:3763:1: entryRuleServiceImplementation returns [EObject current=null] : iv_ruleServiceImplementation= ruleServiceImplementation EOF ;
     public final EObject entryRuleServiceImplementation() throws RecognitionException {
         EObject current = null;
 
@@ -9163,8 +9337,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3703:2: (iv_ruleServiceImplementation= ruleServiceImplementation EOF )
-            // InternalRoom.g:3704:2: iv_ruleServiceImplementation= ruleServiceImplementation EOF
+            // InternalRoom.g:3764:2: (iv_ruleServiceImplementation= ruleServiceImplementation EOF )
+            // InternalRoom.g:3765:2: iv_ruleServiceImplementation= ruleServiceImplementation EOF
             {
              newCompositeNode(grammarAccess.getServiceImplementationRule()); 
             pushFollow(FOLLOW_1);
@@ -9191,7 +9365,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleServiceImplementation"
-    // InternalRoom.g:3711:1: ruleServiceImplementation returns [EObject current=null] : (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalRoom.g:3772:1: ruleServiceImplementation returns [EObject current=null] : (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleServiceImplementation() throws RecognitionException {
         EObject current = null;
 
@@ -9202,13 +9376,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3714:28: ( (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalRoom.g:3715:1: (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:3775:28: ( (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:3776:1: (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalRoom.g:3715:1: (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
-            // InternalRoom.g:3715:3: otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:3776:1: (otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:3776:3: otherlv_0= 'ServiceImplementation' otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
             {
-            otherlv_0=(Token)match(input,63,FOLLOW_86); 
+            otherlv_0=(Token)match(input,63,FOLLOW_87); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getServiceImplementationAccess().getServiceImplementationKeyword_0());
                 
@@ -9216,11 +9390,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getServiceImplementationAccess().getOfKeyword_1());
                 
-            // InternalRoom.g:3723:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:3724:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:3784:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:3785:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:3724:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:3725:3: otherlv_2= RULE_ID
+            // InternalRoom.g:3785:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:3786:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -9258,7 +9432,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLogicalSystem"
-    // InternalRoom.g:3744:1: entryRuleLogicalSystem returns [EObject current=null] : iv_ruleLogicalSystem= ruleLogicalSystem EOF ;
+    // InternalRoom.g:3805:1: entryRuleLogicalSystem returns [EObject current=null] : iv_ruleLogicalSystem= ruleLogicalSystem EOF ;
     public final EObject entryRuleLogicalSystem() throws RecognitionException {
         EObject current = null;
 
@@ -9266,8 +9440,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3745:2: (iv_ruleLogicalSystem= ruleLogicalSystem EOF )
-            // InternalRoom.g:3746:2: iv_ruleLogicalSystem= ruleLogicalSystem EOF
+            // InternalRoom.g:3806:2: (iv_ruleLogicalSystem= ruleLogicalSystem EOF )
+            // InternalRoom.g:3807:2: iv_ruleLogicalSystem= ruleLogicalSystem EOF
             {
              newCompositeNode(grammarAccess.getLogicalSystemRule()); 
             pushFollow(FOLLOW_1);
@@ -9294,7 +9468,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLogicalSystem"
-    // InternalRoom.g:3753:1: ruleLogicalSystem returns [EObject current=null] : (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' ) ;
+    // InternalRoom.g:3814:1: ruleLogicalSystem returns [EObject current=null] : (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' ) ;
     public final EObject ruleLogicalSystem() throws RecognitionException {
         EObject current = null;
 
@@ -9316,21 +9490,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3756:28: ( (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' ) )
-            // InternalRoom.g:3757:1: (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' )
+            // InternalRoom.g:3817:28: ( (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' ) )
+            // InternalRoom.g:3818:1: (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' )
             {
-            // InternalRoom.g:3757:1: (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' )
-            // InternalRoom.g:3757:3: otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}'
+            // InternalRoom.g:3818:1: (otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}' )
+            // InternalRoom.g:3818:3: otherlv_0= 'LogicalSystem' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )* otherlv_8= '}'
             {
             otherlv_0=(Token)match(input,64,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getLogicalSystemAccess().getLogicalSystemKeyword_0());
                 
-            // InternalRoom.g:3761:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:3762:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3822:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:3823:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:3762:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:3763:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:3823:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3824:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_4); 
 
@@ -9352,19 +9526,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:3779:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt88=2;
-            int LA88_0 = input.LA(1);
+            // InternalRoom.g:3840:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt90=2;
+            int LA90_0 = input.LA(1);
 
-            if ( (LA88_0==34) ) {
-                alt88=1;
+            if ( (LA90_0==34) ) {
+                alt90=1;
             }
-            switch (alt88) {
+            switch (alt90) {
                 case 1 :
-                    // InternalRoom.g:3780:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:3841:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:3780:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:3781:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:3841:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:3842:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getLogicalSystemAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -9394,32 +9568,32 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,14,FOLLOW_87); 
+            otherlv_3=(Token)match(input,14,FOLLOW_88); 
 
                 	newLeafNode(otherlv_3, grammarAccess.getLogicalSystemAccess().getLeftCurlyBracketKeyword_3());
                 
-            // InternalRoom.g:3801:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
-            loop89:
+            // InternalRoom.g:3862:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
+            loop91:
             do {
-                int alt89=2;
-                int LA89_0 = input.LA(1);
+                int alt91=2;
+                int LA91_0 = input.LA(1);
 
-                if ( (LA89_0==108) ) {
-                    alt89=1;
+                if ( (LA91_0==108) ) {
+                    alt91=1;
                 }
 
 
-                switch (alt89) {
+                switch (alt91) {
             	case 1 :
-            	    // InternalRoom.g:3802:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:3863:1: (lv_annotations_4_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:3802:1: (lv_annotations_4_0= ruleAnnotation )
-            	    // InternalRoom.g:3803:3: lv_annotations_4_0= ruleAnnotation
+            	    // InternalRoom.g:3863:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:3864:3: lv_annotations_4_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getLogicalSystemAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_87);
+            	    pushFollow(FOLLOW_88);
             	    lv_annotations_4_0=ruleAnnotation();
 
             	    state._fsp--;
@@ -9443,47 +9617,47 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop89;
+            	    break loop91;
                 }
             } while (true);
 
-            // InternalRoom.g:3819:3: ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )*
-            loop90:
+            // InternalRoom.g:3880:3: ( ( (lv_connections_5_0= ruleLayerConnection ) ) | ( (lv_bindings_6_0= ruleBinding ) ) | ( (lv_subSystems_7_0= ruleSubSystemRef ) ) )*
+            loop92:
             do {
-                int alt90=4;
+                int alt92=4;
                 switch ( input.LA(1) ) {
                 case 74:
                     {
-                    alt90=1;
+                    alt92=1;
                     }
                     break;
                 case 70:
                     {
-                    alt90=2;
+                    alt92=2;
                     }
                     break;
                 case 65:
                     {
-                    alt90=3;
+                    alt92=3;
                     }
                     break;
 
                 }
 
-                switch (alt90) {
+                switch (alt92) {
             	case 1 :
-            	    // InternalRoom.g:3819:4: ( (lv_connections_5_0= ruleLayerConnection ) )
+            	    // InternalRoom.g:3880:4: ( (lv_connections_5_0= ruleLayerConnection ) )
             	    {
-            	    // InternalRoom.g:3819:4: ( (lv_connections_5_0= ruleLayerConnection ) )
-            	    // InternalRoom.g:3820:1: (lv_connections_5_0= ruleLayerConnection )
+            	    // InternalRoom.g:3880:4: ( (lv_connections_5_0= ruleLayerConnection ) )
+            	    // InternalRoom.g:3881:1: (lv_connections_5_0= ruleLayerConnection )
             	    {
-            	    // InternalRoom.g:3820:1: (lv_connections_5_0= ruleLayerConnection )
-            	    // InternalRoom.g:3821:3: lv_connections_5_0= ruleLayerConnection
+            	    // InternalRoom.g:3881:1: (lv_connections_5_0= ruleLayerConnection )
+            	    // InternalRoom.g:3882:3: lv_connections_5_0= ruleLayerConnection
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getLogicalSystemAccess().getConnectionsLayerConnectionParserRuleCall_5_0_0()); 
             	    	    
-            	    pushFollow(FOLLOW_88);
+            	    pushFollow(FOLLOW_89);
             	    lv_connections_5_0=ruleLayerConnection();
 
             	    state._fsp--;
@@ -9509,18 +9683,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:3838:6: ( (lv_bindings_6_0= ruleBinding ) )
+            	    // InternalRoom.g:3899:6: ( (lv_bindings_6_0= ruleBinding ) )
             	    {
-            	    // InternalRoom.g:3838:6: ( (lv_bindings_6_0= ruleBinding ) )
-            	    // InternalRoom.g:3839:1: (lv_bindings_6_0= ruleBinding )
+            	    // InternalRoom.g:3899:6: ( (lv_bindings_6_0= ruleBinding ) )
+            	    // InternalRoom.g:3900:1: (lv_bindings_6_0= ruleBinding )
             	    {
-            	    // InternalRoom.g:3839:1: (lv_bindings_6_0= ruleBinding )
-            	    // InternalRoom.g:3840:3: lv_bindings_6_0= ruleBinding
+            	    // InternalRoom.g:3900:1: (lv_bindings_6_0= ruleBinding )
+            	    // InternalRoom.g:3901:3: lv_bindings_6_0= ruleBinding
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getLogicalSystemAccess().getBindingsBindingParserRuleCall_5_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_88);
+            	    pushFollow(FOLLOW_89);
             	    lv_bindings_6_0=ruleBinding();
 
             	    state._fsp--;
@@ -9546,18 +9720,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:3857:6: ( (lv_subSystems_7_0= ruleSubSystemRef ) )
+            	    // InternalRoom.g:3918:6: ( (lv_subSystems_7_0= ruleSubSystemRef ) )
             	    {
-            	    // InternalRoom.g:3857:6: ( (lv_subSystems_7_0= ruleSubSystemRef ) )
-            	    // InternalRoom.g:3858:1: (lv_subSystems_7_0= ruleSubSystemRef )
+            	    // InternalRoom.g:3918:6: ( (lv_subSystems_7_0= ruleSubSystemRef ) )
+            	    // InternalRoom.g:3919:1: (lv_subSystems_7_0= ruleSubSystemRef )
             	    {
-            	    // InternalRoom.g:3858:1: (lv_subSystems_7_0= ruleSubSystemRef )
-            	    // InternalRoom.g:3859:3: lv_subSystems_7_0= ruleSubSystemRef
+            	    // InternalRoom.g:3919:1: (lv_subSystems_7_0= ruleSubSystemRef )
+            	    // InternalRoom.g:3920:3: lv_subSystems_7_0= ruleSubSystemRef
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getLogicalSystemAccess().getSubSystemsSubSystemRefParserRuleCall_5_2_0()); 
             	    	    
-            	    pushFollow(FOLLOW_88);
+            	    pushFollow(FOLLOW_89);
             	    lv_subSystems_7_0=ruleSubSystemRef();
 
             	    state._fsp--;
@@ -9584,7 +9758,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop90;
+            	    break loop92;
                 }
             } while (true);
 
@@ -9613,7 +9787,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubSystemRef"
-    // InternalRoom.g:3889:1: entryRuleSubSystemRef returns [EObject current=null] : iv_ruleSubSystemRef= ruleSubSystemRef EOF ;
+    // InternalRoom.g:3950:1: entryRuleSubSystemRef returns [EObject current=null] : iv_ruleSubSystemRef= ruleSubSystemRef EOF ;
     public final EObject entryRuleSubSystemRef() throws RecognitionException {
         EObject current = null;
 
@@ -9621,8 +9795,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3890:2: (iv_ruleSubSystemRef= ruleSubSystemRef EOF )
-            // InternalRoom.g:3891:2: iv_ruleSubSystemRef= ruleSubSystemRef EOF
+            // InternalRoom.g:3951:2: (iv_ruleSubSystemRef= ruleSubSystemRef EOF )
+            // InternalRoom.g:3952:2: iv_ruleSubSystemRef= ruleSubSystemRef EOF
             {
              newCompositeNode(grammarAccess.getSubSystemRefRule()); 
             pushFollow(FOLLOW_1);
@@ -9649,7 +9823,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSubSystemRef"
-    // InternalRoom.g:3898:1: ruleSubSystemRef returns [EObject current=null] : (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:3959:1: ruleSubSystemRef returns [EObject current=null] : (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? ) ;
     public final EObject ruleSubSystemRef() throws RecognitionException {
         EObject current = null;
 
@@ -9662,21 +9836,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3901:28: ( (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:3902:1: (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? )
+            // InternalRoom.g:3962:28: ( (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:3963:1: (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:3902:1: (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? )
-            // InternalRoom.g:3902:3: otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )?
+            // InternalRoom.g:3963:1: (otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )? )
+            // InternalRoom.g:3963:3: otherlv_0= 'SubSystemRef' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= ':' ( ( ruleFQN ) ) ( (lv_docu_4_0= ruleDocumentation ) )?
             {
             otherlv_0=(Token)match(input,65,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSubSystemRefAccess().getSubSystemRefKeyword_0());
                 
-            // InternalRoom.g:3906:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:3907:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3967:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:3968:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:3907:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:3908:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:3968:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:3969:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -9702,11 +9876,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSubSystemRefAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:3928:1: ( ( ruleFQN ) )
-            // InternalRoom.g:3929:1: ( ruleFQN )
+            // InternalRoom.g:3989:1: ( ( ruleFQN ) )
+            // InternalRoom.g:3990:1: ( ruleFQN )
             {
-            // InternalRoom.g:3929:1: ( ruleFQN )
-            // InternalRoom.g:3930:3: ruleFQN
+            // InternalRoom.g:3990:1: ( ruleFQN )
+            // InternalRoom.g:3991:3: ruleFQN
             {
 
             			if (current==null) {
@@ -9730,19 +9904,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:3943:2: ( (lv_docu_4_0= ruleDocumentation ) )?
-            int alt91=2;
-            int LA91_0 = input.LA(1);
+            // InternalRoom.g:4004:2: ( (lv_docu_4_0= ruleDocumentation ) )?
+            int alt93=2;
+            int LA93_0 = input.LA(1);
 
-            if ( (LA91_0==34) ) {
-                alt91=1;
+            if ( (LA93_0==34) ) {
+                alt93=1;
             }
-            switch (alt91) {
+            switch (alt93) {
                 case 1 :
-                    // InternalRoom.g:3944:1: (lv_docu_4_0= ruleDocumentation )
+                    // InternalRoom.g:4005:1: (lv_docu_4_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:3944:1: (lv_docu_4_0= ruleDocumentation )
-                    // InternalRoom.g:3945:3: lv_docu_4_0= ruleDocumentation
+                    // InternalRoom.g:4005:1: (lv_docu_4_0= ruleDocumentation )
+                    // InternalRoom.g:4006:3: lv_docu_4_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getSubSystemRefAccess().getDocuDocumentationParserRuleCall_4_0()); 
@@ -9793,7 +9967,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubSystemClass"
-    // InternalRoom.g:3969:1: entryRuleSubSystemClass returns [EObject current=null] : iv_ruleSubSystemClass= ruleSubSystemClass EOF ;
+    // InternalRoom.g:4030:1: entryRuleSubSystemClass returns [EObject current=null] : iv_ruleSubSystemClass= ruleSubSystemClass EOF ;
     public final EObject entryRuleSubSystemClass() throws RecognitionException {
         EObject current = null;
 
@@ -9801,8 +9975,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:3970:2: (iv_ruleSubSystemClass= ruleSubSystemClass EOF )
-            // InternalRoom.g:3971:2: iv_ruleSubSystemClass= ruleSubSystemClass EOF
+            // InternalRoom.g:4031:2: (iv_ruleSubSystemClass= ruleSubSystemClass EOF )
+            // InternalRoom.g:4032:2: iv_ruleSubSystemClass= ruleSubSystemClass EOF
             {
              newCompositeNode(grammarAccess.getSubSystemClassRule()); 
             pushFollow(FOLLOW_1);
@@ -9829,7 +10003,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSubSystemClass"
-    // InternalRoom.g:3978:1: ruleSubSystemClass returns [EObject current=null] : (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' ) ;
+    // InternalRoom.g:4039:1: ruleSubSystemClass returns [EObject current=null] : (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' ) ;
     public final EObject ruleSubSystemClass() throws RecognitionException {
         EObject current = null;
 
@@ -9868,21 +10042,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:3981:28: ( (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' ) )
-            // InternalRoom.g:3982:1: (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' )
+            // InternalRoom.g:4042:28: ( (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' ) )
+            // InternalRoom.g:4043:1: (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' )
             {
-            // InternalRoom.g:3982:1: (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' )
-            // InternalRoom.g:3982:3: otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}'
+            // InternalRoom.g:4043:1: (otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}' )
+            // InternalRoom.g:4043:3: otherlv_0= 'SubSystemClass' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' ( (lv_annotations_4_0= ruleAnnotation ) )* (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )? (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )? (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )? ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )* otherlv_18= '}'
             {
             otherlv_0=(Token)match(input,66,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSubSystemClassAccess().getSubSystemClassKeyword_0());
                 
-            // InternalRoom.g:3986:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:3987:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:4047:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:4048:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:3987:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:3988:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:4048:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:4049:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_4); 
 
@@ -9904,19 +10078,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4004:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt92=2;
-            int LA92_0 = input.LA(1);
+            // InternalRoom.g:4065:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt94=2;
+            int LA94_0 = input.LA(1);
 
-            if ( (LA92_0==34) ) {
-                alt92=1;
+            if ( (LA94_0==34) ) {
+                alt94=1;
             }
-            switch (alt92) {
+            switch (alt94) {
                 case 1 :
-                    // InternalRoom.g:4005:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:4066:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:4005:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:4006:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:4066:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:4067:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -9946,32 +10120,32 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,14,FOLLOW_89); 
+            otherlv_3=(Token)match(input,14,FOLLOW_90); 
 
                 	newLeafNode(otherlv_3, grammarAccess.getSubSystemClassAccess().getLeftCurlyBracketKeyword_3());
                 
-            // InternalRoom.g:4026:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
-            loop93:
+            // InternalRoom.g:4087:1: ( (lv_annotations_4_0= ruleAnnotation ) )*
+            loop95:
             do {
-                int alt93=2;
-                int LA93_0 = input.LA(1);
+                int alt95=2;
+                int LA95_0 = input.LA(1);
 
-                if ( (LA93_0==108) ) {
-                    alt93=1;
+                if ( (LA95_0==108) ) {
+                    alt95=1;
                 }
 
 
-                switch (alt93) {
+                switch (alt95) {
             	case 1 :
-            	    // InternalRoom.g:4027:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:4088:1: (lv_annotations_4_0= ruleAnnotation )
             	    {
-            	    // InternalRoom.g:4027:1: (lv_annotations_4_0= ruleAnnotation )
-            	    // InternalRoom.g:4028:3: lv_annotations_4_0= ruleAnnotation
+            	    // InternalRoom.g:4088:1: (lv_annotations_4_0= ruleAnnotation )
+            	    // InternalRoom.g:4089:3: lv_annotations_4_0= ruleAnnotation
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_89);
+            	    pushFollow(FOLLOW_90);
             	    lv_annotations_4_0=ruleAnnotation();
 
             	    state._fsp--;
@@ -9995,35 +10169,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop93;
+            	    break loop95;
                 }
             } while (true);
 
-            // InternalRoom.g:4044:3: (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )?
-            int alt94=2;
-            int LA94_0 = input.LA(1);
+            // InternalRoom.g:4105:3: (otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) ) )?
+            int alt96=2;
+            int LA96_0 = input.LA(1);
 
-            if ( (LA94_0==30) ) {
-                alt94=1;
+            if ( (LA96_0==30) ) {
+                alt96=1;
             }
-            switch (alt94) {
+            switch (alt96) {
                 case 1 :
-                    // InternalRoom.g:4044:5: otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) )
+                    // InternalRoom.g:4105:5: otherlv_5= 'usercode1' ( (lv_userCode1_6_0= ruleDetailCode ) )
                     {
-                    otherlv_5=(Token)match(input,30,FOLLOW_90); 
+                    otherlv_5=(Token)match(input,30,FOLLOW_91); 
 
                         	newLeafNode(otherlv_5, grammarAccess.getSubSystemClassAccess().getUsercode1Keyword_5_0());
                         
-                    // InternalRoom.g:4048:1: ( (lv_userCode1_6_0= ruleDetailCode ) )
-                    // InternalRoom.g:4049:1: (lv_userCode1_6_0= ruleDetailCode )
+                    // InternalRoom.g:4109:1: ( (lv_userCode1_6_0= ruleDetailCode ) )
+                    // InternalRoom.g:4110:1: (lv_userCode1_6_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:4049:1: (lv_userCode1_6_0= ruleDetailCode )
-                    // InternalRoom.g:4050:3: lv_userCode1_6_0= ruleDetailCode
+                    // InternalRoom.g:4110:1: (lv_userCode1_6_0= ruleDetailCode )
+                    // InternalRoom.g:4111:3: lv_userCode1_6_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getUserCode1DetailCodeParserRuleCall_5_1_0()); 
                     	    
-                    pushFollow(FOLLOW_91);
+                    pushFollow(FOLLOW_92);
                     lv_userCode1_6_0=ruleDetailCode();
 
                     state._fsp--;
@@ -10051,31 +10225,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4066:4: (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )?
-            int alt95=2;
-            int LA95_0 = input.LA(1);
+            // InternalRoom.g:4127:4: (otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) ) )?
+            int alt97=2;
+            int LA97_0 = input.LA(1);
 
-            if ( (LA95_0==31) ) {
-                alt95=1;
+            if ( (LA97_0==31) ) {
+                alt97=1;
             }
-            switch (alt95) {
+            switch (alt97) {
                 case 1 :
-                    // InternalRoom.g:4066:6: otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) )
+                    // InternalRoom.g:4127:6: otherlv_7= 'usercode2' ( (lv_userCode2_8_0= ruleDetailCode ) )
                     {
-                    otherlv_7=(Token)match(input,31,FOLLOW_92); 
+                    otherlv_7=(Token)match(input,31,FOLLOW_93); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getSubSystemClassAccess().getUsercode2Keyword_6_0());
                         
-                    // InternalRoom.g:4070:1: ( (lv_userCode2_8_0= ruleDetailCode ) )
-                    // InternalRoom.g:4071:1: (lv_userCode2_8_0= ruleDetailCode )
+                    // InternalRoom.g:4131:1: ( (lv_userCode2_8_0= ruleDetailCode ) )
+                    // InternalRoom.g:4132:1: (lv_userCode2_8_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:4071:1: (lv_userCode2_8_0= ruleDetailCode )
-                    // InternalRoom.g:4072:3: lv_userCode2_8_0= ruleDetailCode
+                    // InternalRoom.g:4132:1: (lv_userCode2_8_0= ruleDetailCode )
+                    // InternalRoom.g:4133:3: lv_userCode2_8_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getUserCode2DetailCodeParserRuleCall_6_1_0()); 
                     	    
-                    pushFollow(FOLLOW_93);
+                    pushFollow(FOLLOW_94);
                     lv_userCode2_8_0=ruleDetailCode();
 
                     state._fsp--;
@@ -10103,31 +10277,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4088:4: (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )?
-            int alt96=2;
-            int LA96_0 = input.LA(1);
+            // InternalRoom.g:4149:4: (otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) ) )?
+            int alt98=2;
+            int LA98_0 = input.LA(1);
 
-            if ( (LA96_0==32) ) {
-                alt96=1;
+            if ( (LA98_0==32) ) {
+                alt98=1;
             }
-            switch (alt96) {
+            switch (alt98) {
                 case 1 :
-                    // InternalRoom.g:4088:6: otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) )
+                    // InternalRoom.g:4149:6: otherlv_9= 'usercode3' ( (lv_userCode3_10_0= ruleDetailCode ) )
                     {
-                    otherlv_9=(Token)match(input,32,FOLLOW_94); 
+                    otherlv_9=(Token)match(input,32,FOLLOW_95); 
 
                         	newLeafNode(otherlv_9, grammarAccess.getSubSystemClassAccess().getUsercode3Keyword_7_0());
                         
-                    // InternalRoom.g:4092:1: ( (lv_userCode3_10_0= ruleDetailCode ) )
-                    // InternalRoom.g:4093:1: (lv_userCode3_10_0= ruleDetailCode )
+                    // InternalRoom.g:4153:1: ( (lv_userCode3_10_0= ruleDetailCode ) )
+                    // InternalRoom.g:4154:1: (lv_userCode3_10_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:4093:1: (lv_userCode3_10_0= ruleDetailCode )
-                    // InternalRoom.g:4094:3: lv_userCode3_10_0= ruleDetailCode
+                    // InternalRoom.g:4154:1: (lv_userCode3_10_0= ruleDetailCode )
+                    // InternalRoom.g:4155:3: lv_userCode3_10_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getUserCode3DetailCodeParserRuleCall_7_1_0()); 
                     	    
-                    pushFollow(FOLLOW_95);
+                    pushFollow(FOLLOW_96);
                     lv_userCode3_10_0=ruleDetailCode();
 
                     state._fsp--;
@@ -10155,66 +10329,66 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4110:4: ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )*
-            loop97:
+            // InternalRoom.g:4171:4: ( ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) ) | ( (lv_threads_12_0= ruleLogicalThread ) ) | ( (lv_connections_13_0= ruleLayerConnection ) ) | ( (lv_bindings_14_0= ruleBinding ) ) | ( (lv_actorRefs_15_0= ruleActorRef ) ) | ( (lv_serviceProvisionPoints_16_0= ruleSPP ) ) | ( (lv_relayPorts_17_0= rulePort ) ) )*
+            loop99:
             do {
-                int alt97=8;
+                int alt99=8;
                 switch ( input.LA(1) ) {
                 case 68:
                     {
-                    alt97=1;
+                    alt99=1;
                     }
                     break;
                 case 67:
                     {
-                    alt97=2;
+                    alt99=2;
                     }
                     break;
                 case 74:
                     {
-                    alt97=3;
+                    alt99=3;
                     }
                     break;
                 case 70:
                     {
-                    alt97=4;
+                    alt99=4;
                     }
                     break;
                 case 77:
                 case 111:
                 case 127:
                     {
-                    alt97=5;
+                    alt99=5;
                     }
                     break;
                 case 62:
                     {
-                    alt97=6;
+                    alt99=6;
                     }
                     break;
                 case 47:
                 case 59:
                     {
-                    alt97=7;
+                    alt99=7;
                     }
                     break;
 
                 }
 
-                switch (alt97) {
+                switch (alt99) {
             	case 1 :
-            	    // InternalRoom.g:4110:5: ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) )
+            	    // InternalRoom.g:4171:5: ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) )
             	    {
-            	    // InternalRoom.g:4110:5: ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) )
-            	    // InternalRoom.g:4111:1: (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping )
+            	    // InternalRoom.g:4171:5: ( (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping ) )
+            	    // InternalRoom.g:4172:1: (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping )
             	    {
-            	    // InternalRoom.g:4111:1: (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping )
-            	    // InternalRoom.g:4112:3: lv_actorInstanceMappings_11_0= ruleActorInstanceMapping
+            	    // InternalRoom.g:4172:1: (lv_actorInstanceMappings_11_0= ruleActorInstanceMapping )
+            	    // InternalRoom.g:4173:3: lv_actorInstanceMappings_11_0= ruleActorInstanceMapping
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_8_0_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_actorInstanceMappings_11_0=ruleActorInstanceMapping();
 
             	    state._fsp--;
@@ -10240,18 +10414,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:4129:6: ( (lv_threads_12_0= ruleLogicalThread ) )
+            	    // InternalRoom.g:4190:6: ( (lv_threads_12_0= ruleLogicalThread ) )
             	    {
-            	    // InternalRoom.g:4129:6: ( (lv_threads_12_0= ruleLogicalThread ) )
-            	    // InternalRoom.g:4130:1: (lv_threads_12_0= ruleLogicalThread )
+            	    // InternalRoom.g:4190:6: ( (lv_threads_12_0= ruleLogicalThread ) )
+            	    // InternalRoom.g:4191:1: (lv_threads_12_0= ruleLogicalThread )
             	    {
-            	    // InternalRoom.g:4130:1: (lv_threads_12_0= ruleLogicalThread )
-            	    // InternalRoom.g:4131:3: lv_threads_12_0= ruleLogicalThread
+            	    // InternalRoom.g:4191:1: (lv_threads_12_0= ruleLogicalThread )
+            	    // InternalRoom.g:4192:3: lv_threads_12_0= ruleLogicalThread
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getThreadsLogicalThreadParserRuleCall_8_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_threads_12_0=ruleLogicalThread();
 
             	    state._fsp--;
@@ -10277,18 +10451,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:4148:6: ( (lv_connections_13_0= ruleLayerConnection ) )
+            	    // InternalRoom.g:4209:6: ( (lv_connections_13_0= ruleLayerConnection ) )
             	    {
-            	    // InternalRoom.g:4148:6: ( (lv_connections_13_0= ruleLayerConnection ) )
-            	    // InternalRoom.g:4149:1: (lv_connections_13_0= ruleLayerConnection )
+            	    // InternalRoom.g:4209:6: ( (lv_connections_13_0= ruleLayerConnection ) )
+            	    // InternalRoom.g:4210:1: (lv_connections_13_0= ruleLayerConnection )
             	    {
-            	    // InternalRoom.g:4149:1: (lv_connections_13_0= ruleLayerConnection )
-            	    // InternalRoom.g:4150:3: lv_connections_13_0= ruleLayerConnection
+            	    // InternalRoom.g:4210:1: (lv_connections_13_0= ruleLayerConnection )
+            	    // InternalRoom.g:4211:3: lv_connections_13_0= ruleLayerConnection
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getConnectionsLayerConnectionParserRuleCall_8_2_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_connections_13_0=ruleLayerConnection();
 
             	    state._fsp--;
@@ -10314,18 +10488,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 4 :
-            	    // InternalRoom.g:4167:6: ( (lv_bindings_14_0= ruleBinding ) )
+            	    // InternalRoom.g:4228:6: ( (lv_bindings_14_0= ruleBinding ) )
             	    {
-            	    // InternalRoom.g:4167:6: ( (lv_bindings_14_0= ruleBinding ) )
-            	    // InternalRoom.g:4168:1: (lv_bindings_14_0= ruleBinding )
+            	    // InternalRoom.g:4228:6: ( (lv_bindings_14_0= ruleBinding ) )
+            	    // InternalRoom.g:4229:1: (lv_bindings_14_0= ruleBinding )
             	    {
-            	    // InternalRoom.g:4168:1: (lv_bindings_14_0= ruleBinding )
-            	    // InternalRoom.g:4169:3: lv_bindings_14_0= ruleBinding
+            	    // InternalRoom.g:4229:1: (lv_bindings_14_0= ruleBinding )
+            	    // InternalRoom.g:4230:3: lv_bindings_14_0= ruleBinding
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getBindingsBindingParserRuleCall_8_3_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_bindings_14_0=ruleBinding();
 
             	    state._fsp--;
@@ -10351,18 +10525,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 5 :
-            	    // InternalRoom.g:4186:6: ( (lv_actorRefs_15_0= ruleActorRef ) )
+            	    // InternalRoom.g:4247:6: ( (lv_actorRefs_15_0= ruleActorRef ) )
             	    {
-            	    // InternalRoom.g:4186:6: ( (lv_actorRefs_15_0= ruleActorRef ) )
-            	    // InternalRoom.g:4187:1: (lv_actorRefs_15_0= ruleActorRef )
+            	    // InternalRoom.g:4247:6: ( (lv_actorRefs_15_0= ruleActorRef ) )
+            	    // InternalRoom.g:4248:1: (lv_actorRefs_15_0= ruleActorRef )
             	    {
-            	    // InternalRoom.g:4187:1: (lv_actorRefs_15_0= ruleActorRef )
-            	    // InternalRoom.g:4188:3: lv_actorRefs_15_0= ruleActorRef
+            	    // InternalRoom.g:4248:1: (lv_actorRefs_15_0= ruleActorRef )
+            	    // InternalRoom.g:4249:3: lv_actorRefs_15_0= ruleActorRef
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getActorRefsActorRefParserRuleCall_8_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_actorRefs_15_0=ruleActorRef();
 
             	    state._fsp--;
@@ -10388,18 +10562,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 6 :
-            	    // InternalRoom.g:4205:6: ( (lv_serviceProvisionPoints_16_0= ruleSPP ) )
+            	    // InternalRoom.g:4266:6: ( (lv_serviceProvisionPoints_16_0= ruleSPP ) )
             	    {
-            	    // InternalRoom.g:4205:6: ( (lv_serviceProvisionPoints_16_0= ruleSPP ) )
-            	    // InternalRoom.g:4206:1: (lv_serviceProvisionPoints_16_0= ruleSPP )
+            	    // InternalRoom.g:4266:6: ( (lv_serviceProvisionPoints_16_0= ruleSPP ) )
+            	    // InternalRoom.g:4267:1: (lv_serviceProvisionPoints_16_0= ruleSPP )
             	    {
-            	    // InternalRoom.g:4206:1: (lv_serviceProvisionPoints_16_0= ruleSPP )
-            	    // InternalRoom.g:4207:3: lv_serviceProvisionPoints_16_0= ruleSPP
+            	    // InternalRoom.g:4267:1: (lv_serviceProvisionPoints_16_0= ruleSPP )
+            	    // InternalRoom.g:4268:3: lv_serviceProvisionPoints_16_0= ruleSPP
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsSPPParserRuleCall_8_5_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_serviceProvisionPoints_16_0=ruleSPP();
 
             	    state._fsp--;
@@ -10425,18 +10599,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 7 :
-            	    // InternalRoom.g:4224:6: ( (lv_relayPorts_17_0= rulePort ) )
+            	    // InternalRoom.g:4285:6: ( (lv_relayPorts_17_0= rulePort ) )
             	    {
-            	    // InternalRoom.g:4224:6: ( (lv_relayPorts_17_0= rulePort ) )
-            	    // InternalRoom.g:4225:1: (lv_relayPorts_17_0= rulePort )
+            	    // InternalRoom.g:4285:6: ( (lv_relayPorts_17_0= rulePort ) )
+            	    // InternalRoom.g:4286:1: (lv_relayPorts_17_0= rulePort )
             	    {
-            	    // InternalRoom.g:4225:1: (lv_relayPorts_17_0= rulePort )
-            	    // InternalRoom.g:4226:3: lv_relayPorts_17_0= rulePort
+            	    // InternalRoom.g:4286:1: (lv_relayPorts_17_0= rulePort )
+            	    // InternalRoom.g:4287:3: lv_relayPorts_17_0= rulePort
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getSubSystemClassAccess().getRelayPortsPortParserRuleCall_8_6_0()); 
             	    	    
-            	    pushFollow(FOLLOW_95);
+            	    pushFollow(FOLLOW_96);
             	    lv_relayPorts_17_0=rulePort();
 
             	    state._fsp--;
@@ -10463,7 +10637,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop97;
+            	    break loop99;
                 }
             } while (true);
 
@@ -10492,7 +10666,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLogicalThread"
-    // InternalRoom.g:4254:1: entryRuleLogicalThread returns [EObject current=null] : iv_ruleLogicalThread= ruleLogicalThread EOF ;
+    // InternalRoom.g:4315:1: entryRuleLogicalThread returns [EObject current=null] : iv_ruleLogicalThread= ruleLogicalThread EOF ;
     public final EObject entryRuleLogicalThread() throws RecognitionException {
         EObject current = null;
 
@@ -10500,8 +10674,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4255:2: (iv_ruleLogicalThread= ruleLogicalThread EOF )
-            // InternalRoom.g:4256:2: iv_ruleLogicalThread= ruleLogicalThread EOF
+            // InternalRoom.g:4316:2: (iv_ruleLogicalThread= ruleLogicalThread EOF )
+            // InternalRoom.g:4317:2: iv_ruleLogicalThread= ruleLogicalThread EOF
             {
              newCompositeNode(grammarAccess.getLogicalThreadRule()); 
             pushFollow(FOLLOW_1);
@@ -10528,7 +10702,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLogicalThread"
-    // InternalRoom.g:4263:1: ruleLogicalThread returns [EObject current=null] : (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) ) ;
+    // InternalRoom.g:4324:1: ruleLogicalThread returns [EObject current=null] : (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) ) ;
     public final EObject ruleLogicalThread() throws RecognitionException {
         EObject current = null;
 
@@ -10538,21 +10712,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4266:28: ( (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) ) )
-            // InternalRoom.g:4267:1: (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:4327:28: ( (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) ) )
+            // InternalRoom.g:4328:1: (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) )
             {
-            // InternalRoom.g:4267:1: (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) )
-            // InternalRoom.g:4267:3: otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:4328:1: (otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:4328:3: otherlv_0= 'LogicalThread' ( (lv_name_1_0= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,67,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getLogicalThreadAccess().getLogicalThreadKeyword_0());
                 
-            // InternalRoom.g:4271:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:4272:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:4332:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:4333:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:4272:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:4273:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:4333:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:4334:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_2); 
 
@@ -10595,7 +10769,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleActorInstanceMapping"
-    // InternalRoom.g:4297:1: entryRuleActorInstanceMapping returns [EObject current=null] : iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF ;
+    // InternalRoom.g:4358:1: entryRuleActorInstanceMapping returns [EObject current=null] : iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF ;
     public final EObject entryRuleActorInstanceMapping() throws RecognitionException {
         EObject current = null;
 
@@ -10603,8 +10777,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4298:2: (iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF )
-            // InternalRoom.g:4299:2: iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF
+            // InternalRoom.g:4359:2: (iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF )
+            // InternalRoom.g:4360:2: iv_ruleActorInstanceMapping= ruleActorInstanceMapping EOF
             {
              newCompositeNode(grammarAccess.getActorInstanceMappingRule()); 
             pushFollow(FOLLOW_1);
@@ -10631,7 +10805,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleActorInstanceMapping"
-    // InternalRoom.g:4306:1: ruleActorInstanceMapping returns [EObject current=null] : (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? ) ;
+    // InternalRoom.g:4367:1: ruleActorInstanceMapping returns [EObject current=null] : (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? ) ;
     public final EObject ruleActorInstanceMapping() throws RecognitionException {
         EObject current = null;
 
@@ -10648,21 +10822,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4309:28: ( (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? ) )
-            // InternalRoom.g:4310:1: (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? )
+            // InternalRoom.g:4370:28: ( (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? ) )
+            // InternalRoom.g:4371:1: (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? )
             {
-            // InternalRoom.g:4310:1: (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? )
-            // InternalRoom.g:4310:3: otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )?
+            // InternalRoom.g:4371:1: (otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )? )
+            // InternalRoom.g:4371:3: otherlv_0= 'ActorInstanceMapping' ( (lv_path_1_0= ruleRefPath ) ) otherlv_2= '->' ( (otherlv_3= RULE_ID ) ) (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )?
             {
             otherlv_0=(Token)match(input,68,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingKeyword_0());
                 
-            // InternalRoom.g:4314:1: ( (lv_path_1_0= ruleRefPath ) )
-            // InternalRoom.g:4315:1: (lv_path_1_0= ruleRefPath )
+            // InternalRoom.g:4375:1: ( (lv_path_1_0= ruleRefPath ) )
+            // InternalRoom.g:4376:1: (lv_path_1_0= ruleRefPath )
             {
-            // InternalRoom.g:4315:1: (lv_path_1_0= ruleRefPath )
-            // InternalRoom.g:4316:3: lv_path_1_0= ruleRefPath
+            // InternalRoom.g:4376:1: (lv_path_1_0= ruleRefPath )
+            // InternalRoom.g:4377:3: lv_path_1_0= ruleRefPath
             {
              
             	        newCompositeNode(grammarAccess.getActorInstanceMappingAccess().getPathRefPathParserRuleCall_1_0()); 
@@ -10693,18 +10867,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getActorInstanceMappingAccess().getHyphenMinusGreaterThanSignKeyword_2());
                 
-            // InternalRoom.g:4336:1: ( (otherlv_3= RULE_ID ) )
-            // InternalRoom.g:4337:1: (otherlv_3= RULE_ID )
+            // InternalRoom.g:4397:1: ( (otherlv_3= RULE_ID ) )
+            // InternalRoom.g:4398:1: (otherlv_3= RULE_ID )
             {
-            // InternalRoom.g:4337:1: (otherlv_3= RULE_ID )
-            // InternalRoom.g:4338:3: otherlv_3= RULE_ID
+            // InternalRoom.g:4398:1: (otherlv_3= RULE_ID )
+            // InternalRoom.g:4399:3: otherlv_3= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getActorInstanceMappingRule());
             	        }
                     
-            otherlv_3=(Token)match(input,RULE_ID,FOLLOW_96); 
+            otherlv_3=(Token)match(input,RULE_ID,FOLLOW_97); 
 
             		newLeafNode(otherlv_3, grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadCrossReference_3_0()); 
             	
@@ -10714,43 +10888,43 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4349:2: (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )?
-            int alt99=2;
-            int LA99_0 = input.LA(1);
+            // InternalRoom.g:4410:2: (otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}' )?
+            int alt101=2;
+            int LA101_0 = input.LA(1);
 
-            if ( (LA99_0==14) ) {
-                alt99=1;
+            if ( (LA101_0==14) ) {
+                alt101=1;
             }
-            switch (alt99) {
+            switch (alt101) {
                 case 1 :
-                    // InternalRoom.g:4349:4: otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}'
+                    // InternalRoom.g:4410:4: otherlv_4= '{' ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )* otherlv_6= '}'
                     {
-                    otherlv_4=(Token)match(input,14,FOLLOW_97); 
+                    otherlv_4=(Token)match(input,14,FOLLOW_98); 
 
                         	newLeafNode(otherlv_4, grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0());
                         
-                    // InternalRoom.g:4353:1: ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )*
-                    loop98:
+                    // InternalRoom.g:4414:1: ( (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping ) )*
+                    loop100:
                     do {
-                        int alt98=2;
-                        int LA98_0 = input.LA(1);
+                        int alt100=2;
+                        int LA100_0 = input.LA(1);
 
-                        if ( (LA98_0==68) ) {
-                            alt98=1;
+                        if ( (LA100_0==68) ) {
+                            alt100=1;
                         }
 
 
-                        switch (alt98) {
+                        switch (alt100) {
                     	case 1 :
-                    	    // InternalRoom.g:4354:1: (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping )
+                    	    // InternalRoom.g:4415:1: (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping )
                     	    {
-                    	    // InternalRoom.g:4354:1: (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping )
-                    	    // InternalRoom.g:4355:3: lv_actorInstanceMappings_5_0= ruleActorInstanceMapping
+                    	    // InternalRoom.g:4415:1: (lv_actorInstanceMappings_5_0= ruleActorInstanceMapping )
+                    	    // InternalRoom.g:4416:3: lv_actorInstanceMappings_5_0= ruleActorInstanceMapping
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_4_1_0()); 
                     	    	    
-                    	    pushFollow(FOLLOW_97);
+                    	    pushFollow(FOLLOW_98);
                     	    lv_actorInstanceMappings_5_0=ruleActorInstanceMapping();
 
                     	    state._fsp--;
@@ -10774,7 +10948,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop98;
+                    	    break loop100;
                         }
                     } while (true);
 
@@ -10809,7 +10983,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefPath"
-    // InternalRoom.g:4383:1: entryRuleRefPath returns [EObject current=null] : iv_ruleRefPath= ruleRefPath EOF ;
+    // InternalRoom.g:4444:1: entryRuleRefPath returns [EObject current=null] : iv_ruleRefPath= ruleRefPath EOF ;
     public final EObject entryRuleRefPath() throws RecognitionException {
         EObject current = null;
 
@@ -10817,8 +10991,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4384:2: (iv_ruleRefPath= ruleRefPath EOF )
-            // InternalRoom.g:4385:2: iv_ruleRefPath= ruleRefPath EOF
+            // InternalRoom.g:4445:2: (iv_ruleRefPath= ruleRefPath EOF )
+            // InternalRoom.g:4446:2: iv_ruleRefPath= ruleRefPath EOF
             {
              newCompositeNode(grammarAccess.getRefPathRule()); 
             pushFollow(FOLLOW_1);
@@ -10845,7 +11019,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefPath"
-    // InternalRoom.g:4392:1: ruleRefPath returns [EObject current=null] : ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* ) ;
+    // InternalRoom.g:4453:1: ruleRefPath returns [EObject current=null] : ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* ) ;
     public final EObject ruleRefPath() throws RecognitionException {
         EObject current = null;
 
@@ -10858,22 +11032,22 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4395:28: ( ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* ) )
-            // InternalRoom.g:4396:1: ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* )
+            // InternalRoom.g:4456:28: ( ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* ) )
+            // InternalRoom.g:4457:1: ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* )
             {
-            // InternalRoom.g:4396:1: ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* )
-            // InternalRoom.g:4396:2: ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )*
+            // InternalRoom.g:4457:1: ( ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )* )
+            // InternalRoom.g:4457:2: ( (lv_refs_0_0= ruleRefSegment ) ) (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )*
             {
-            // InternalRoom.g:4396:2: ( (lv_refs_0_0= ruleRefSegment ) )
-            // InternalRoom.g:4397:1: (lv_refs_0_0= ruleRefSegment )
+            // InternalRoom.g:4457:2: ( (lv_refs_0_0= ruleRefSegment ) )
+            // InternalRoom.g:4458:1: (lv_refs_0_0= ruleRefSegment )
             {
-            // InternalRoom.g:4397:1: (lv_refs_0_0= ruleRefSegment )
-            // InternalRoom.g:4398:3: lv_refs_0_0= ruleRefSegment
+            // InternalRoom.g:4458:1: (lv_refs_0_0= ruleRefSegment )
+            // InternalRoom.g:4459:3: lv_refs_0_0= ruleRefSegment
             {
              
             	        newCompositeNode(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_0_0()); 
             	    
-            pushFollow(FOLLOW_98);
+            pushFollow(FOLLOW_99);
             lv_refs_0_0=ruleRefSegment();
 
             state._fsp--;
@@ -10895,35 +11069,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4414:2: (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )*
-            loop100:
+            // InternalRoom.g:4475:2: (otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) ) )*
+            loop102:
             do {
-                int alt100=2;
-                int LA100_0 = input.LA(1);
+                int alt102=2;
+                int LA102_0 = input.LA(1);
 
-                if ( (LA100_0==69) ) {
-                    alt100=1;
+                if ( (LA102_0==69) ) {
+                    alt102=1;
                 }
 
 
-                switch (alt100) {
+                switch (alt102) {
             	case 1 :
-            	    // InternalRoom.g:4414:4: otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) )
+            	    // InternalRoom.g:4475:4: otherlv_1= '/' ( (lv_refs_2_0= ruleRefSegment ) )
             	    {
             	    otherlv_1=(Token)match(input,69,FOLLOW_3); 
 
             	        	newLeafNode(otherlv_1, grammarAccess.getRefPathAccess().getSolidusKeyword_1_0());
             	        
-            	    // InternalRoom.g:4418:1: ( (lv_refs_2_0= ruleRefSegment ) )
-            	    // InternalRoom.g:4419:1: (lv_refs_2_0= ruleRefSegment )
+            	    // InternalRoom.g:4479:1: ( (lv_refs_2_0= ruleRefSegment ) )
+            	    // InternalRoom.g:4480:1: (lv_refs_2_0= ruleRefSegment )
             	    {
-            	    // InternalRoom.g:4419:1: (lv_refs_2_0= ruleRefSegment )
-            	    // InternalRoom.g:4420:3: lv_refs_2_0= ruleRefSegment
+            	    // InternalRoom.g:4480:1: (lv_refs_2_0= ruleRefSegment )
+            	    // InternalRoom.g:4481:3: lv_refs_2_0= ruleRefSegment
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_1_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_98);
+            	    pushFollow(FOLLOW_99);
             	    lv_refs_2_0=ruleRefSegment();
 
             	    state._fsp--;
@@ -10950,7 +11124,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop100;
+            	    break loop102;
                 }
             } while (true);
 
@@ -10975,7 +11149,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefSegment"
-    // InternalRoom.g:4444:1: entryRuleRefSegment returns [EObject current=null] : iv_ruleRefSegment= ruleRefSegment EOF ;
+    // InternalRoom.g:4505:1: entryRuleRefSegment returns [EObject current=null] : iv_ruleRefSegment= ruleRefSegment EOF ;
     public final EObject entryRuleRefSegment() throws RecognitionException {
         EObject current = null;
 
@@ -10983,8 +11157,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4445:2: (iv_ruleRefSegment= ruleRefSegment EOF )
-            // InternalRoom.g:4446:2: iv_ruleRefSegment= ruleRefSegment EOF
+            // InternalRoom.g:4506:2: (iv_ruleRefSegment= ruleRefSegment EOF )
+            // InternalRoom.g:4507:2: iv_ruleRefSegment= ruleRefSegment EOF
             {
              newCompositeNode(grammarAccess.getRefSegmentRule()); 
             pushFollow(FOLLOW_1);
@@ -11011,7 +11185,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefSegment"
-    // InternalRoom.g:4453:1: ruleRefSegment returns [EObject current=null] : ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? ) ;
+    // InternalRoom.g:4514:1: ruleRefSegment returns [EObject current=null] : ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? ) ;
     public final EObject ruleRefSegment() throws RecognitionException {
         EObject current = null;
 
@@ -11022,19 +11196,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4456:28: ( ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? ) )
-            // InternalRoom.g:4457:1: ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? )
+            // InternalRoom.g:4517:28: ( ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? ) )
+            // InternalRoom.g:4518:1: ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? )
             {
-            // InternalRoom.g:4457:1: ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? )
-            // InternalRoom.g:4457:2: ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )?
+            // InternalRoom.g:4518:1: ( ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )? )
+            // InternalRoom.g:4518:2: ( (lv_ref_0_0= RULE_ID ) ) (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )?
             {
-            // InternalRoom.g:4457:2: ( (lv_ref_0_0= RULE_ID ) )
-            // InternalRoom.g:4458:1: (lv_ref_0_0= RULE_ID )
+            // InternalRoom.g:4518:2: ( (lv_ref_0_0= RULE_ID ) )
+            // InternalRoom.g:4519:1: (lv_ref_0_0= RULE_ID )
             {
-            // InternalRoom.g:4458:1: (lv_ref_0_0= RULE_ID )
-            // InternalRoom.g:4459:3: lv_ref_0_0= RULE_ID
+            // InternalRoom.g:4519:1: (lv_ref_0_0= RULE_ID )
+            // InternalRoom.g:4520:3: lv_ref_0_0= RULE_ID
             {
-            lv_ref_0_0=(Token)match(input,RULE_ID,FOLLOW_99); 
+            lv_ref_0_0=(Token)match(input,RULE_ID,FOLLOW_100); 
 
             			newLeafNode(lv_ref_0_0, grammarAccess.getRefSegmentAccess().getRefIDTerminalRuleCall_0_0()); 
             		
@@ -11054,26 +11228,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4475:2: (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )?
-            int alt101=2;
-            int LA101_0 = input.LA(1);
+            // InternalRoom.g:4536:2: (otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) ) )?
+            int alt103=2;
+            int LA103_0 = input.LA(1);
 
-            if ( (LA101_0==16) ) {
-                alt101=1;
+            if ( (LA103_0==16) ) {
+                alt103=1;
             }
-            switch (alt101) {
+            switch (alt103) {
                 case 1 :
-                    // InternalRoom.g:4475:4: otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) )
+                    // InternalRoom.g:4536:4: otherlv_1= ':' ( (lv_idx_2_0= RULE_INT ) )
                     {
                     otherlv_1=(Token)match(input,16,FOLLOW_34); 
 
                         	newLeafNode(otherlv_1, grammarAccess.getRefSegmentAccess().getColonKeyword_1_0());
                         
-                    // InternalRoom.g:4479:1: ( (lv_idx_2_0= RULE_INT ) )
-                    // InternalRoom.g:4480:1: (lv_idx_2_0= RULE_INT )
+                    // InternalRoom.g:4540:1: ( (lv_idx_2_0= RULE_INT ) )
+                    // InternalRoom.g:4541:1: (lv_idx_2_0= RULE_INT )
                     {
-                    // InternalRoom.g:4480:1: (lv_idx_2_0= RULE_INT )
-                    // InternalRoom.g:4481:3: lv_idx_2_0= RULE_INT
+                    // InternalRoom.g:4541:1: (lv_idx_2_0= RULE_INT )
+                    // InternalRoom.g:4542:3: lv_idx_2_0= RULE_INT
                     {
                     lv_idx_2_0=(Token)match(input,RULE_INT,FOLLOW_2); 
 
@@ -11122,7 +11296,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleBinding"
-    // InternalRoom.g:4505:1: entryRuleBinding returns [EObject current=null] : iv_ruleBinding= ruleBinding EOF ;
+    // InternalRoom.g:4566:1: entryRuleBinding returns [EObject current=null] : iv_ruleBinding= ruleBinding EOF ;
     public final EObject entryRuleBinding() throws RecognitionException {
         EObject current = null;
 
@@ -11130,8 +11304,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4506:2: (iv_ruleBinding= ruleBinding EOF )
-            // InternalRoom.g:4507:2: iv_ruleBinding= ruleBinding EOF
+            // InternalRoom.g:4567:2: (iv_ruleBinding= ruleBinding EOF )
+            // InternalRoom.g:4568:2: iv_ruleBinding= ruleBinding EOF
             {
              newCompositeNode(grammarAccess.getBindingRule()); 
             pushFollow(FOLLOW_1);
@@ -11158,7 +11332,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleBinding"
-    // InternalRoom.g:4514:1: ruleBinding returns [EObject current=null] : (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) ) ;
+    // InternalRoom.g:4575:1: ruleBinding returns [EObject current=null] : (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) ) ;
     public final EObject ruleBinding() throws RecognitionException {
         EObject current = null;
 
@@ -11172,26 +11346,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4517:28: ( (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) ) )
-            // InternalRoom.g:4518:1: (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) )
+            // InternalRoom.g:4578:28: ( (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) ) )
+            // InternalRoom.g:4579:1: (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) )
             {
-            // InternalRoom.g:4518:1: (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) )
-            // InternalRoom.g:4518:3: otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) )
+            // InternalRoom.g:4579:1: (otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) ) )
+            // InternalRoom.g:4579:3: otherlv_0= 'Binding' ( (lv_endpoint1_1_0= ruleBindingEndPoint ) ) otherlv_2= 'and' ( (lv_endpoint2_3_0= ruleBindingEndPoint ) )
             {
             otherlv_0=(Token)match(input,70,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getBindingAccess().getBindingKeyword_0());
                 
-            // InternalRoom.g:4522:1: ( (lv_endpoint1_1_0= ruleBindingEndPoint ) )
-            // InternalRoom.g:4523:1: (lv_endpoint1_1_0= ruleBindingEndPoint )
+            // InternalRoom.g:4583:1: ( (lv_endpoint1_1_0= ruleBindingEndPoint ) )
+            // InternalRoom.g:4584:1: (lv_endpoint1_1_0= ruleBindingEndPoint )
             {
-            // InternalRoom.g:4523:1: (lv_endpoint1_1_0= ruleBindingEndPoint )
-            // InternalRoom.g:4524:3: lv_endpoint1_1_0= ruleBindingEndPoint
+            // InternalRoom.g:4584:1: (lv_endpoint1_1_0= ruleBindingEndPoint )
+            // InternalRoom.g:4585:3: lv_endpoint1_1_0= ruleBindingEndPoint
             {
              
             	        newCompositeNode(grammarAccess.getBindingAccess().getEndpoint1BindingEndPointParserRuleCall_1_0()); 
             	    
-            pushFollow(FOLLOW_100);
+            pushFollow(FOLLOW_101);
             lv_endpoint1_1_0=ruleBindingEndPoint();
 
             state._fsp--;
@@ -11217,11 +11391,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getBindingAccess().getAndKeyword_2());
                 
-            // InternalRoom.g:4544:1: ( (lv_endpoint2_3_0= ruleBindingEndPoint ) )
-            // InternalRoom.g:4545:1: (lv_endpoint2_3_0= ruleBindingEndPoint )
+            // InternalRoom.g:4605:1: ( (lv_endpoint2_3_0= ruleBindingEndPoint ) )
+            // InternalRoom.g:4606:1: (lv_endpoint2_3_0= ruleBindingEndPoint )
             {
-            // InternalRoom.g:4545:1: (lv_endpoint2_3_0= ruleBindingEndPoint )
-            // InternalRoom.g:4546:3: lv_endpoint2_3_0= ruleBindingEndPoint
+            // InternalRoom.g:4606:1: (lv_endpoint2_3_0= ruleBindingEndPoint )
+            // InternalRoom.g:4607:3: lv_endpoint2_3_0= ruleBindingEndPoint
             {
              
             	        newCompositeNode(grammarAccess.getBindingAccess().getEndpoint2BindingEndPointParserRuleCall_3_0()); 
@@ -11269,7 +11443,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleBindingEndPoint"
-    // InternalRoom.g:4570:1: entryRuleBindingEndPoint returns [EObject current=null] : iv_ruleBindingEndPoint= ruleBindingEndPoint EOF ;
+    // InternalRoom.g:4631:1: entryRuleBindingEndPoint returns [EObject current=null] : iv_ruleBindingEndPoint= ruleBindingEndPoint EOF ;
     public final EObject entryRuleBindingEndPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11277,8 +11451,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4571:2: (iv_ruleBindingEndPoint= ruleBindingEndPoint EOF )
-            // InternalRoom.g:4572:2: iv_ruleBindingEndPoint= ruleBindingEndPoint EOF
+            // InternalRoom.g:4632:2: (iv_ruleBindingEndPoint= ruleBindingEndPoint EOF )
+            // InternalRoom.g:4633:2: iv_ruleBindingEndPoint= ruleBindingEndPoint EOF
             {
              newCompositeNode(grammarAccess.getBindingEndPointRule()); 
             pushFollow(FOLLOW_1);
@@ -11305,7 +11479,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleBindingEndPoint"
-    // InternalRoom.g:4579:1: ruleBindingEndPoint returns [EObject current=null] : ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? ) ;
+    // InternalRoom.g:4640:1: ruleBindingEndPoint returns [EObject current=null] : ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? ) ;
     public final EObject ruleBindingEndPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11318,39 +11492,39 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4582:28: ( ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? ) )
-            // InternalRoom.g:4583:1: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? )
+            // InternalRoom.g:4643:28: ( ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? ) )
+            // InternalRoom.g:4644:1: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? )
             {
-            // InternalRoom.g:4583:1: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? )
-            // InternalRoom.g:4583:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )?
+            // InternalRoom.g:4644:1: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )? )
+            // InternalRoom.g:4644:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )?
             {
-            // InternalRoom.g:4583:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )?
-            int alt102=2;
-            int LA102_0 = input.LA(1);
+            // InternalRoom.g:4644:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' )?
+            int alt104=2;
+            int LA104_0 = input.LA(1);
 
-            if ( (LA102_0==RULE_ID) ) {
-                int LA102_1 = input.LA(2);
+            if ( (LA104_0==RULE_ID) ) {
+                int LA104_1 = input.LA(2);
 
-                if ( (LA102_1==72) ) {
-                    alt102=1;
+                if ( (LA104_1==72) ) {
+                    alt104=1;
                 }
             }
-            switch (alt102) {
+            switch (alt104) {
                 case 1 :
-                    // InternalRoom.g:4583:3: ( (otherlv_0= RULE_ID ) ) otherlv_1= '.'
+                    // InternalRoom.g:4644:3: ( (otherlv_0= RULE_ID ) ) otherlv_1= '.'
                     {
-                    // InternalRoom.g:4583:3: ( (otherlv_0= RULE_ID ) )
-                    // InternalRoom.g:4584:1: (otherlv_0= RULE_ID )
+                    // InternalRoom.g:4644:3: ( (otherlv_0= RULE_ID ) )
+                    // InternalRoom.g:4645:1: (otherlv_0= RULE_ID )
                     {
-                    // InternalRoom.g:4584:1: (otherlv_0= RULE_ID )
-                    // InternalRoom.g:4585:3: otherlv_0= RULE_ID
+                    // InternalRoom.g:4645:1: (otherlv_0= RULE_ID )
+                    // InternalRoom.g:4646:3: otherlv_0= RULE_ID
                     {
 
                     			if (current==null) {
                     	            current = createModelElement(grammarAccess.getBindingEndPointRule());
                     	        }
                             
-                    otherlv_0=(Token)match(input,RULE_ID,FOLLOW_101); 
+                    otherlv_0=(Token)match(input,RULE_ID,FOLLOW_102); 
 
                     		newLeafNode(otherlv_0, grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefCrossReference_0_0_0()); 
                     	
@@ -11370,18 +11544,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4600:3: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:4601:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:4661:3: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:4662:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:4601:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:4602:3: otherlv_2= RULE_ID
+            // InternalRoom.g:4662:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:4663:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getBindingEndPointRule());
             	        }
                     
-            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_102); 
+            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_103); 
 
             		newLeafNode(otherlv_2, grammarAccess.getBindingEndPointAccess().getPortPortCrossReference_1_0()); 
             	
@@ -11391,26 +11565,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4613:2: (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )?
-            int alt103=2;
-            int LA103_0 = input.LA(1);
+            // InternalRoom.g:4674:2: (otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) ) )?
+            int alt105=2;
+            int LA105_0 = input.LA(1);
 
-            if ( (LA103_0==73) ) {
-                alt103=1;
+            if ( (LA105_0==73) ) {
+                alt105=1;
             }
-            switch (alt103) {
+            switch (alt105) {
                 case 1 :
-                    // InternalRoom.g:4613:4: otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) )
+                    // InternalRoom.g:4674:4: otherlv_3= 'sub' ( (otherlv_4= RULE_ID ) )
                     {
                     otherlv_3=(Token)match(input,73,FOLLOW_3); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getBindingEndPointAccess().getSubKeyword_2_0());
                         
-                    // InternalRoom.g:4617:1: ( (otherlv_4= RULE_ID ) )
-                    // InternalRoom.g:4618:1: (otherlv_4= RULE_ID )
+                    // InternalRoom.g:4678:1: ( (otherlv_4= RULE_ID ) )
+                    // InternalRoom.g:4679:1: (otherlv_4= RULE_ID )
                     {
-                    // InternalRoom.g:4618:1: (otherlv_4= RULE_ID )
-                    // InternalRoom.g:4619:3: otherlv_4= RULE_ID
+                    // InternalRoom.g:4679:1: (otherlv_4= RULE_ID )
+                    // InternalRoom.g:4680:3: otherlv_4= RULE_ID
                     {
 
                     			if (current==null) {
@@ -11454,7 +11628,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLayerConnection"
-    // InternalRoom.g:4638:1: entryRuleLayerConnection returns [EObject current=null] : iv_ruleLayerConnection= ruleLayerConnection EOF ;
+    // InternalRoom.g:4699:1: entryRuleLayerConnection returns [EObject current=null] : iv_ruleLayerConnection= ruleLayerConnection EOF ;
     public final EObject entryRuleLayerConnection() throws RecognitionException {
         EObject current = null;
 
@@ -11462,8 +11636,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4639:2: (iv_ruleLayerConnection= ruleLayerConnection EOF )
-            // InternalRoom.g:4640:2: iv_ruleLayerConnection= ruleLayerConnection EOF
+            // InternalRoom.g:4700:2: (iv_ruleLayerConnection= ruleLayerConnection EOF )
+            // InternalRoom.g:4701:2: iv_ruleLayerConnection= ruleLayerConnection EOF
             {
              newCompositeNode(grammarAccess.getLayerConnectionRule()); 
             pushFollow(FOLLOW_1);
@@ -11490,7 +11664,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLayerConnection"
-    // InternalRoom.g:4647:1: ruleLayerConnection returns [EObject current=null] : (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) ) ;
+    // InternalRoom.g:4708:1: ruleLayerConnection returns [EObject current=null] : (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) ) ;
     public final EObject ruleLayerConnection() throws RecognitionException {
         EObject current = null;
 
@@ -11504,26 +11678,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4650:28: ( (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) ) )
-            // InternalRoom.g:4651:1: (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) )
+            // InternalRoom.g:4711:28: ( (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) ) )
+            // InternalRoom.g:4712:1: (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) )
             {
-            // InternalRoom.g:4651:1: (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) )
-            // InternalRoom.g:4651:3: otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) )
+            // InternalRoom.g:4712:1: (otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) ) )
+            // InternalRoom.g:4712:3: otherlv_0= 'LayerConnection' ( (lv_from_1_0= ruleSAPoint ) ) otherlv_2= 'satisfied_by' ( (lv_to_3_0= ruleSPPoint ) )
             {
-            otherlv_0=(Token)match(input,74,FOLLOW_103); 
+            otherlv_0=(Token)match(input,74,FOLLOW_104); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getLayerConnectionAccess().getLayerConnectionKeyword_0());
                 
-            // InternalRoom.g:4655:1: ( (lv_from_1_0= ruleSAPoint ) )
-            // InternalRoom.g:4656:1: (lv_from_1_0= ruleSAPoint )
+            // InternalRoom.g:4716:1: ( (lv_from_1_0= ruleSAPoint ) )
+            // InternalRoom.g:4717:1: (lv_from_1_0= ruleSAPoint )
             {
-            // InternalRoom.g:4656:1: (lv_from_1_0= ruleSAPoint )
-            // InternalRoom.g:4657:3: lv_from_1_0= ruleSAPoint
+            // InternalRoom.g:4717:1: (lv_from_1_0= ruleSAPoint )
+            // InternalRoom.g:4718:3: lv_from_1_0= ruleSAPoint
             {
              
             	        newCompositeNode(grammarAccess.getLayerConnectionAccess().getFromSAPointParserRuleCall_1_0()); 
             	    
-            pushFollow(FOLLOW_104);
+            pushFollow(FOLLOW_105);
             lv_from_1_0=ruleSAPoint();
 
             state._fsp--;
@@ -11549,11 +11723,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getLayerConnectionAccess().getSatisfied_byKeyword_2());
                 
-            // InternalRoom.g:4677:1: ( (lv_to_3_0= ruleSPPoint ) )
-            // InternalRoom.g:4678:1: (lv_to_3_0= ruleSPPoint )
+            // InternalRoom.g:4738:1: ( (lv_to_3_0= ruleSPPoint ) )
+            // InternalRoom.g:4739:1: (lv_to_3_0= ruleSPPoint )
             {
-            // InternalRoom.g:4678:1: (lv_to_3_0= ruleSPPoint )
-            // InternalRoom.g:4679:3: lv_to_3_0= ruleSPPoint
+            // InternalRoom.g:4739:1: (lv_to_3_0= ruleSPPoint )
+            // InternalRoom.g:4740:3: lv_to_3_0= ruleSPPoint
             {
              
             	        newCompositeNode(grammarAccess.getLayerConnectionAccess().getToSPPointParserRuleCall_3_0()); 
@@ -11601,7 +11775,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSAPoint"
-    // InternalRoom.g:4703:1: entryRuleSAPoint returns [EObject current=null] : iv_ruleSAPoint= ruleSAPoint EOF ;
+    // InternalRoom.g:4764:1: entryRuleSAPoint returns [EObject current=null] : iv_ruleSAPoint= ruleSAPoint EOF ;
     public final EObject entryRuleSAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11609,8 +11783,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4704:2: (iv_ruleSAPoint= ruleSAPoint EOF )
-            // InternalRoom.g:4705:2: iv_ruleSAPoint= ruleSAPoint EOF
+            // InternalRoom.g:4765:2: (iv_ruleSAPoint= ruleSAPoint EOF )
+            // InternalRoom.g:4766:2: iv_ruleSAPoint= ruleSAPoint EOF
             {
              newCompositeNode(grammarAccess.getSAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -11637,7 +11811,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSAPoint"
-    // InternalRoom.g:4712:1: ruleSAPoint returns [EObject current=null] : (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint ) ;
+    // InternalRoom.g:4773:1: ruleSAPoint returns [EObject current=null] : (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint ) ;
     public final EObject ruleSAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11649,28 +11823,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4715:28: ( (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint ) )
-            // InternalRoom.g:4716:1: (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint )
+            // InternalRoom.g:4776:28: ( (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint ) )
+            // InternalRoom.g:4777:1: (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint )
             {
-            // InternalRoom.g:4716:1: (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint )
-            int alt104=2;
-            int LA104_0 = input.LA(1);
+            // InternalRoom.g:4777:1: (this_RefSAPoint_0= ruleRefSAPoint | this_RelaySAPoint_1= ruleRelaySAPoint )
+            int alt106=2;
+            int LA106_0 = input.LA(1);
 
-            if ( (LA104_0==17) ) {
-                alt104=1;
+            if ( (LA106_0==17) ) {
+                alt106=1;
             }
-            else if ( (LA104_0==76) ) {
-                alt104=2;
+            else if ( (LA106_0==76) ) {
+                alt106=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 104, 0, input);
+                    new NoViableAltException("", 106, 0, input);
 
                 throw nvae;
             }
-            switch (alt104) {
+            switch (alt106) {
                 case 1 :
-                    // InternalRoom.g:4717:5: this_RefSAPoint_0= ruleRefSAPoint
+                    // InternalRoom.g:4778:5: this_RefSAPoint_0= ruleRefSAPoint
                     {
                      
                             newCompositeNode(grammarAccess.getSAPointAccess().getRefSAPointParserRuleCall_0()); 
@@ -11688,7 +11862,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4727:5: this_RelaySAPoint_1= ruleRelaySAPoint
+                    // InternalRoom.g:4788:5: this_RelaySAPoint_1= ruleRelaySAPoint
                     {
                      
                             newCompositeNode(grammarAccess.getSAPointAccess().getRelaySAPointParserRuleCall_1()); 
@@ -11726,7 +11900,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefSAPoint"
-    // InternalRoom.g:4743:1: entryRuleRefSAPoint returns [EObject current=null] : iv_ruleRefSAPoint= ruleRefSAPoint EOF ;
+    // InternalRoom.g:4804:1: entryRuleRefSAPoint returns [EObject current=null] : iv_ruleRefSAPoint= ruleRefSAPoint EOF ;
     public final EObject entryRuleRefSAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11734,8 +11908,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4744:2: (iv_ruleRefSAPoint= ruleRefSAPoint EOF )
-            // InternalRoom.g:4745:2: iv_ruleRefSAPoint= ruleRefSAPoint EOF
+            // InternalRoom.g:4805:2: (iv_ruleRefSAPoint= ruleRefSAPoint EOF )
+            // InternalRoom.g:4806:2: iv_ruleRefSAPoint= ruleRefSAPoint EOF
             {
              newCompositeNode(grammarAccess.getRefSAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -11762,7 +11936,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefSAPoint"
-    // InternalRoom.g:4752:1: ruleRefSAPoint returns [EObject current=null] : (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalRoom.g:4813:1: ruleRefSAPoint returns [EObject current=null] : (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleRefSAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11772,21 +11946,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4755:28: ( (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalRoom.g:4756:1: (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:4816:28: ( (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:4817:1: (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalRoom.g:4756:1: (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) )
-            // InternalRoom.g:4756:3: otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:4817:1: (otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:4817:3: otherlv_0= 'ref' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,17,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getRefSAPointAccess().getRefKeyword_0());
                 
-            // InternalRoom.g:4760:1: ( (otherlv_1= RULE_ID ) )
-            // InternalRoom.g:4761:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:4821:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:4822:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:4761:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:4762:3: otherlv_1= RULE_ID
+            // InternalRoom.g:4822:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:4823:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -11824,7 +11998,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRelaySAPoint"
-    // InternalRoom.g:4781:1: entryRuleRelaySAPoint returns [EObject current=null] : iv_ruleRelaySAPoint= ruleRelaySAPoint EOF ;
+    // InternalRoom.g:4842:1: entryRuleRelaySAPoint returns [EObject current=null] : iv_ruleRelaySAPoint= ruleRelaySAPoint EOF ;
     public final EObject entryRuleRelaySAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11832,8 +12006,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4782:2: (iv_ruleRelaySAPoint= ruleRelaySAPoint EOF )
-            // InternalRoom.g:4783:2: iv_ruleRelaySAPoint= ruleRelaySAPoint EOF
+            // InternalRoom.g:4843:2: (iv_ruleRelaySAPoint= ruleRelaySAPoint EOF )
+            // InternalRoom.g:4844:2: iv_ruleRelaySAPoint= ruleRelaySAPoint EOF
             {
              newCompositeNode(grammarAccess.getRelaySAPointRule()); 
             pushFollow(FOLLOW_1);
@@ -11860,7 +12034,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRelaySAPoint"
-    // InternalRoom.g:4790:1: ruleRelaySAPoint returns [EObject current=null] : (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalRoom.g:4851:1: ruleRelaySAPoint returns [EObject current=null] : (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleRelaySAPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11870,21 +12044,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4793:28: ( (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalRoom.g:4794:1: (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:4854:28: ( (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:4855:1: (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalRoom.g:4794:1: (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) )
-            // InternalRoom.g:4794:3: otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:4855:1: (otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:4855:3: otherlv_0= 'relay_sap' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,76,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getRelaySAPointAccess().getRelay_sapKeyword_0());
                 
-            // InternalRoom.g:4798:1: ( (otherlv_1= RULE_ID ) )
-            // InternalRoom.g:4799:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:4859:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:4860:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:4799:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:4800:3: otherlv_1= RULE_ID
+            // InternalRoom.g:4860:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:4861:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -11922,7 +12096,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSPPoint"
-    // InternalRoom.g:4819:1: entryRuleSPPoint returns [EObject current=null] : iv_ruleSPPoint= ruleSPPoint EOF ;
+    // InternalRoom.g:4880:1: entryRuleSPPoint returns [EObject current=null] : iv_ruleSPPoint= ruleSPPoint EOF ;
     public final EObject entryRuleSPPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11930,8 +12104,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4820:2: (iv_ruleSPPoint= ruleSPPoint EOF )
-            // InternalRoom.g:4821:2: iv_ruleSPPoint= ruleSPPoint EOF
+            // InternalRoom.g:4881:2: (iv_ruleSPPoint= ruleSPPoint EOF )
+            // InternalRoom.g:4882:2: iv_ruleSPPoint= ruleSPPoint EOF
             {
              newCompositeNode(grammarAccess.getSPPointRule()); 
             pushFollow(FOLLOW_1);
@@ -11958,7 +12132,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSPPoint"
-    // InternalRoom.g:4828:1: ruleSPPoint returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalRoom.g:4889:1: ruleSPPoint returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleSPPoint() throws RecognitionException {
         EObject current = null;
 
@@ -11969,24 +12143,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4831:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalRoom.g:4832:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:4892:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:4893:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalRoom.g:4832:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) )
-            // InternalRoom.g:4832:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:4893:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:4893:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= '.' ( (otherlv_2= RULE_ID ) )
             {
-            // InternalRoom.g:4832:2: ( (otherlv_0= RULE_ID ) )
-            // InternalRoom.g:4833:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:4893:2: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:4894:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:4833:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:4834:3: otherlv_0= RULE_ID
+            // InternalRoom.g:4894:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:4895:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getSPPointRule());
             	        }
                     
-            otherlv_0=(Token)match(input,RULE_ID,FOLLOW_101); 
+            otherlv_0=(Token)match(input,RULE_ID,FOLLOW_102); 
 
             		newLeafNode(otherlv_0, grammarAccess.getSPPointAccess().getRefActorContainerRefCrossReference_0_0()); 
             	
@@ -12000,11 +12174,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getSPPointAccess().getFullStopKeyword_1());
                 
-            // InternalRoom.g:4849:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:4850:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:4910:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:4911:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:4850:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:4851:3: otherlv_2= RULE_ID
+            // InternalRoom.g:4911:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:4912:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -12042,7 +12216,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleActorRef"
-    // InternalRoom.g:4870:1: entryRuleActorRef returns [EObject current=null] : iv_ruleActorRef= ruleActorRef EOF ;
+    // InternalRoom.g:4931:1: entryRuleActorRef returns [EObject current=null] : iv_ruleActorRef= ruleActorRef EOF ;
     public final EObject entryRuleActorRef() throws RecognitionException {
         EObject current = null;
 
@@ -12050,8 +12224,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4871:2: (iv_ruleActorRef= ruleActorRef EOF )
-            // InternalRoom.g:4872:2: iv_ruleActorRef= ruleActorRef EOF
+            // InternalRoom.g:4932:2: (iv_ruleActorRef= ruleActorRef EOF )
+            // InternalRoom.g:4933:2: iv_ruleActorRef= ruleActorRef EOF
             {
              newCompositeNode(grammarAccess.getActorRefRule()); 
             pushFollow(FOLLOW_1);
@@ -12078,7 +12252,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleActorRef"
-    // InternalRoom.g:4879:1: ruleActorRef returns [EObject current=null] : ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:4940:1: ruleActorRef returns [EObject current=null] : ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? ) ;
     public final EObject ruleActorRef() throws RecognitionException {
         EObject current = null;
 
@@ -12095,30 +12269,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:4882:28: ( ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:4883:1: ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? )
+            // InternalRoom.g:4943:28: ( ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:4944:1: ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:4883:1: ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? )
-            // InternalRoom.g:4883:2: ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )?
+            // InternalRoom.g:4944:1: ( ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )? )
+            // InternalRoom.g:4944:2: ( (lv_refType_0_0= ruleReferenceType ) )? otherlv_1= 'ActorRef' ( (lv_name_2_0= RULE_ID ) ) ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )? otherlv_4= ':' ( ( ruleFQN ) ) ( (lv_docu_6_0= ruleDocumentation ) )?
             {
-            // InternalRoom.g:4883:2: ( (lv_refType_0_0= ruleReferenceType ) )?
-            int alt105=2;
-            int LA105_0 = input.LA(1);
+            // InternalRoom.g:4944:2: ( (lv_refType_0_0= ruleReferenceType ) )?
+            int alt107=2;
+            int LA107_0 = input.LA(1);
 
-            if ( (LA105_0==111||LA105_0==127) ) {
-                alt105=1;
+            if ( (LA107_0==111||LA107_0==127) ) {
+                alt107=1;
             }
-            switch (alt105) {
+            switch (alt107) {
                 case 1 :
-                    // InternalRoom.g:4884:1: (lv_refType_0_0= ruleReferenceType )
+                    // InternalRoom.g:4945:1: (lv_refType_0_0= ruleReferenceType )
                     {
-                    // InternalRoom.g:4884:1: (lv_refType_0_0= ruleReferenceType )
-                    // InternalRoom.g:4885:3: lv_refType_0_0= ruleReferenceType
+                    // InternalRoom.g:4945:1: (lv_refType_0_0= ruleReferenceType )
+                    // InternalRoom.g:4946:3: lv_refType_0_0= ruleReferenceType
                     {
                      
                     	        newCompositeNode(grammarAccess.getActorRefAccess().getRefTypeReferenceTypeEnumRuleCall_0_0()); 
                     	    
-                    pushFollow(FOLLOW_105);
+                    pushFollow(FOLLOW_106);
                     lv_refType_0_0=ruleReferenceType();
 
                     state._fsp--;
@@ -12147,11 +12321,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getActorRefAccess().getActorRefKeyword_1());
                 
-            // InternalRoom.g:4905:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:4906:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:4966:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:4967:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:4906:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:4907:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:4967:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:4968:3: lv_name_2_0= RULE_ID
             {
             lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_33); 
 
@@ -12173,19 +12347,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4923:2: ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )?
-            int alt106=2;
-            int LA106_0 = input.LA(1);
+            // InternalRoom.g:4984:2: ( (lv_multiplicity_3_0= ruleMULTIPLICITY ) )?
+            int alt108=2;
+            int LA108_0 = input.LA(1);
 
-            if ( (LA106_0==34) ) {
-                alt106=1;
+            if ( (LA108_0==34) ) {
+                alt108=1;
             }
-            switch (alt106) {
+            switch (alt108) {
                 case 1 :
-                    // InternalRoom.g:4924:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
+                    // InternalRoom.g:4985:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
                     {
-                    // InternalRoom.g:4924:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
-                    // InternalRoom.g:4925:3: lv_multiplicity_3_0= ruleMULTIPLICITY
+                    // InternalRoom.g:4985:1: (lv_multiplicity_3_0= ruleMULTIPLICITY )
+                    // InternalRoom.g:4986:3: lv_multiplicity_3_0= ruleMULTIPLICITY
                     {
                      
                     	        newCompositeNode(grammarAccess.getActorRefAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
@@ -12219,11 +12393,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getActorRefAccess().getColonKeyword_4());
                 
-            // InternalRoom.g:4945:1: ( ( ruleFQN ) )
-            // InternalRoom.g:4946:1: ( ruleFQN )
+            // InternalRoom.g:5006:1: ( ( ruleFQN ) )
+            // InternalRoom.g:5007:1: ( ruleFQN )
             {
-            // InternalRoom.g:4946:1: ( ruleFQN )
-            // InternalRoom.g:4947:3: ruleFQN
+            // InternalRoom.g:5007:1: ( ruleFQN )
+            // InternalRoom.g:5008:3: ruleFQN
             {
 
             			if (current==null) {
@@ -12247,19 +12421,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:4960:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt107=2;
-            int LA107_0 = input.LA(1);
+            // InternalRoom.g:5021:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt109=2;
+            int LA109_0 = input.LA(1);
 
-            if ( (LA107_0==34) ) {
-                alt107=1;
+            if ( (LA109_0==34) ) {
+                alt109=1;
             }
-            switch (alt107) {
+            switch (alt109) {
                 case 1 :
-                    // InternalRoom.g:4961:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:5022:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:4961:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:4962:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:5022:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:5023:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getActorRefAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -12310,7 +12484,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMULTIPLICITY"
-    // InternalRoom.g:4988:1: entryRuleMULTIPLICITY returns [String current=null] : iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF ;
+    // InternalRoom.g:5049:1: entryRuleMULTIPLICITY returns [String current=null] : iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF ;
     public final String entryRuleMULTIPLICITY() throws RecognitionException {
         String current = null;
 
@@ -12318,8 +12492,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:4989:2: (iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF )
-            // InternalRoom.g:4990:2: iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF
+            // InternalRoom.g:5050:2: (iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF )
+            // InternalRoom.g:5051:2: iv_ruleMULTIPLICITY= ruleMULTIPLICITY EOF
             {
              newCompositeNode(grammarAccess.getMULTIPLICITYRule()); 
             pushFollow(FOLLOW_1);
@@ -12346,7 +12520,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleMULTIPLICITY"
-    // InternalRoom.g:4997:1: ruleMULTIPLICITY returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' ) ;
+    // InternalRoom.g:5058:1: ruleMULTIPLICITY returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' ) ;
     public final AntlrDatatypeRuleToken ruleMULTIPLICITY() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -12356,36 +12530,36 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5000:28: ( (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' ) )
-            // InternalRoom.g:5001:1: (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' )
+            // InternalRoom.g:5061:28: ( (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' ) )
+            // InternalRoom.g:5062:1: (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' )
             {
-            // InternalRoom.g:5001:1: (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' )
-            // InternalRoom.g:5002:2: kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']'
+            // InternalRoom.g:5062:1: (kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']' )
+            // InternalRoom.g:5063:2: kw= '[' (kw= '*' | this_INT_2= RULE_INT ) kw= ']'
             {
-            kw=(Token)match(input,34,FOLLOW_106); 
+            kw=(Token)match(input,34,FOLLOW_107); 
 
                     current.merge(kw);
                     newLeafNode(kw, grammarAccess.getMULTIPLICITYAccess().getLeftSquareBracketKeyword_0()); 
                 
-            // InternalRoom.g:5007:1: (kw= '*' | this_INT_2= RULE_INT )
-            int alt108=2;
-            int LA108_0 = input.LA(1);
+            // InternalRoom.g:5068:1: (kw= '*' | this_INT_2= RULE_INT )
+            int alt110=2;
+            int LA110_0 = input.LA(1);
 
-            if ( (LA108_0==78) ) {
-                alt108=1;
+            if ( (LA110_0==78) ) {
+                alt110=1;
             }
-            else if ( (LA108_0==RULE_INT) ) {
-                alt108=2;
+            else if ( (LA110_0==RULE_INT) ) {
+                alt110=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 108, 0, input);
+                    new NoViableAltException("", 110, 0, input);
 
                 throw nvae;
             }
-            switch (alt108) {
+            switch (alt110) {
                 case 1 :
-                    // InternalRoom.g:5008:2: kw= '*'
+                    // InternalRoom.g:5069:2: kw= '*'
                     {
                     kw=(Token)match(input,78,FOLLOW_35); 
 
@@ -12396,7 +12570,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5014:10: this_INT_2= RULE_INT
+                    // InternalRoom.g:5075:10: this_INT_2= RULE_INT
                     {
                     this_INT_2=(Token)match(input,RULE_INT,FOLLOW_35); 
 
@@ -12437,7 +12611,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationTargetType"
-    // InternalRoom.g:5035:1: entryRuleAnnotationTargetType returns [String current=null] : iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF ;
+    // InternalRoom.g:5096:1: entryRuleAnnotationTargetType returns [String current=null] : iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF ;
     public final String entryRuleAnnotationTargetType() throws RecognitionException {
         String current = null;
 
@@ -12445,8 +12619,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5036:2: (iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF )
-            // InternalRoom.g:5037:2: iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF
+            // InternalRoom.g:5097:2: (iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF )
+            // InternalRoom.g:5098:2: iv_ruleAnnotationTargetType= ruleAnnotationTargetType EOF
             {
              newCompositeNode(grammarAccess.getAnnotationTargetTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -12473,7 +12647,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotationTargetType"
-    // InternalRoom.g:5044:1: ruleAnnotationTargetType returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' ) ;
+    // InternalRoom.g:5105:1: ruleAnnotationTargetType returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' ) ;
     public final AntlrDatatypeRuleToken ruleAnnotationTargetType() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -12482,67 +12656,67 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5047:28: ( (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' ) )
-            // InternalRoom.g:5048:1: (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' )
+            // InternalRoom.g:5108:28: ( (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' ) )
+            // InternalRoom.g:5109:1: (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' )
             {
-            // InternalRoom.g:5048:1: (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' )
-            int alt109=9;
+            // InternalRoom.g:5109:1: (kw= 'DataClass' | kw= 'ActorClass' | kw= 'ActorBehavior' | kw= 'ProtocolClass' | kw= 'CompoundProtocolClass' | kw= 'SubSystemClass' | kw= 'LogicalSystem' | kw= 'Port' | kw= 'Message' )
+            int alt111=9;
             switch ( input.LA(1) ) {
             case 28:
                 {
-                alt109=1;
+                alt111=1;
                 }
                 break;
             case 55:
                 {
-                alt109=2;
+                alt111=2;
                 }
                 break;
             case 79:
                 {
-                alt109=3;
+                alt111=3;
                 }
                 break;
             case 42:
                 {
-                alt109=4;
+                alt111=4;
                 }
                 break;
             case 48:
                 {
-                alt109=5;
+                alt111=5;
                 }
                 break;
             case 66:
                 {
-                alt109=6;
+                alt111=6;
                 }
                 break;
             case 64:
                 {
-                alt109=7;
+                alt111=7;
                 }
                 break;
             case 59:
                 {
-                alt109=8;
+                alt111=8;
                 }
                 break;
             case 51:
                 {
-                alt109=9;
+                alt111=9;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 109, 0, input);
+                    new NoViableAltException("", 111, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt109) {
+            switch (alt111) {
                 case 1 :
-                    // InternalRoom.g:5049:2: kw= 'DataClass'
+                    // InternalRoom.g:5110:2: kw= 'DataClass'
                     {
                     kw=(Token)match(input,28,FOLLOW_2); 
 
@@ -12553,7 +12727,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5056:2: kw= 'ActorClass'
+                    // InternalRoom.g:5117:2: kw= 'ActorClass'
                     {
                     kw=(Token)match(input,55,FOLLOW_2); 
 
@@ -12564,7 +12738,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:5063:2: kw= 'ActorBehavior'
+                    // InternalRoom.g:5124:2: kw= 'ActorBehavior'
                     {
                     kw=(Token)match(input,79,FOLLOW_2); 
 
@@ -12575,7 +12749,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:5070:2: kw= 'ProtocolClass'
+                    // InternalRoom.g:5131:2: kw= 'ProtocolClass'
                     {
                     kw=(Token)match(input,42,FOLLOW_2); 
 
@@ -12586,7 +12760,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:5077:2: kw= 'CompoundProtocolClass'
+                    // InternalRoom.g:5138:2: kw= 'CompoundProtocolClass'
                     {
                     kw=(Token)match(input,48,FOLLOW_2); 
 
@@ -12597,7 +12771,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:5084:2: kw= 'SubSystemClass'
+                    // InternalRoom.g:5145:2: kw= 'SubSystemClass'
                     {
                     kw=(Token)match(input,66,FOLLOW_2); 
 
@@ -12608,7 +12782,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:5091:2: kw= 'LogicalSystem'
+                    // InternalRoom.g:5152:2: kw= 'LogicalSystem'
                     {
                     kw=(Token)match(input,64,FOLLOW_2); 
 
@@ -12619,7 +12793,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:5098:2: kw= 'Port'
+                    // InternalRoom.g:5159:2: kw= 'Port'
                     {
                     kw=(Token)match(input,59,FOLLOW_2); 
 
@@ -12630,7 +12804,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 9 :
-                    // InternalRoom.g:5105:2: kw= 'Message'
+                    // InternalRoom.g:5166:2: kw= 'Message'
                     {
                     kw=(Token)match(input,51,FOLLOW_2); 
 
@@ -12661,7 +12835,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateGraphNode"
-    // InternalRoom.g:5120:1: entryRuleStateGraphNode returns [EObject current=null] : iv_ruleStateGraphNode= ruleStateGraphNode EOF ;
+    // InternalRoom.g:5181:1: entryRuleStateGraphNode returns [EObject current=null] : iv_ruleStateGraphNode= ruleStateGraphNode EOF ;
     public final EObject entryRuleStateGraphNode() throws RecognitionException {
         EObject current = null;
 
@@ -12669,8 +12843,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5121:2: (iv_ruleStateGraphNode= ruleStateGraphNode EOF )
-            // InternalRoom.g:5122:2: iv_ruleStateGraphNode= ruleStateGraphNode EOF
+            // InternalRoom.g:5182:2: (iv_ruleStateGraphNode= ruleStateGraphNode EOF )
+            // InternalRoom.g:5183:2: iv_ruleStateGraphNode= ruleStateGraphNode EOF
             {
              newCompositeNode(grammarAccess.getStateGraphNodeRule()); 
             pushFollow(FOLLOW_1);
@@ -12697,7 +12871,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateGraphNode"
-    // InternalRoom.g:5129:1: ruleStateGraphNode returns [EObject current=null] : (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint ) ;
+    // InternalRoom.g:5190:1: ruleStateGraphNode returns [EObject current=null] : (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint ) ;
     public final EObject ruleStateGraphNode() throws RecognitionException {
         EObject current = null;
 
@@ -12711,21 +12885,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5132:28: ( (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint ) )
-            // InternalRoom.g:5133:1: (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint )
+            // InternalRoom.g:5193:28: ( (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint ) )
+            // InternalRoom.g:5194:1: (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint )
             {
-            // InternalRoom.g:5133:1: (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint )
-            int alt110=3;
+            // InternalRoom.g:5194:1: (this_State_0= ruleState | this_ChoicePoint_1= ruleChoicePoint | this_TrPoint_2= ruleTrPoint )
+            int alt112=3;
             switch ( input.LA(1) ) {
             case 81:
             case 86:
                 {
-                alt110=1;
+                alt112=1;
                 }
                 break;
             case 91:
                 {
-                alt110=2;
+                alt112=2;
                 }
                 break;
             case 87:
@@ -12733,19 +12907,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             case 89:
             case 90:
                 {
-                alt110=3;
+                alt112=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 110, 0, input);
+                    new NoViableAltException("", 112, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt110) {
+            switch (alt112) {
                 case 1 :
-                    // InternalRoom.g:5134:5: this_State_0= ruleState
+                    // InternalRoom.g:5195:5: this_State_0= ruleState
                     {
                      
                             newCompositeNode(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); 
@@ -12763,7 +12937,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5144:5: this_ChoicePoint_1= ruleChoicePoint
+                    // InternalRoom.g:5205:5: this_ChoicePoint_1= ruleChoicePoint
                     {
                      
                             newCompositeNode(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); 
@@ -12781,7 +12955,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:5154:5: this_TrPoint_2= ruleTrPoint
+                    // InternalRoom.g:5215:5: this_TrPoint_2= ruleTrPoint
                     {
                      
                             newCompositeNode(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); 
@@ -12819,7 +12993,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateGraph"
-    // InternalRoom.g:5172:1: entryRuleStateGraph returns [EObject current=null] : iv_ruleStateGraph= ruleStateGraph EOF ;
+    // InternalRoom.g:5233:1: entryRuleStateGraph returns [EObject current=null] : iv_ruleStateGraph= ruleStateGraph EOF ;
     public final EObject entryRuleStateGraph() throws RecognitionException {
         EObject current = null;
 
@@ -12827,8 +13001,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5173:2: (iv_ruleStateGraph= ruleStateGraph EOF )
-            // InternalRoom.g:5174:2: iv_ruleStateGraph= ruleStateGraph EOF
+            // InternalRoom.g:5234:2: (iv_ruleStateGraph= ruleStateGraph EOF )
+            // InternalRoom.g:5235:2: iv_ruleStateGraph= ruleStateGraph EOF
             {
              newCompositeNode(grammarAccess.getStateGraphRule()); 
             pushFollow(FOLLOW_1);
@@ -12855,7 +13029,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateGraph"
-    // InternalRoom.g:5181:1: ruleStateGraph returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' ) ;
+    // InternalRoom.g:5242:1: ruleStateGraph returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' ) ;
     public final EObject ruleStateGraph() throws RecognitionException {
         EObject current = null;
 
@@ -12875,14 +13049,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5184:28: ( ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' ) )
-            // InternalRoom.g:5185:1: ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' )
+            // InternalRoom.g:5245:28: ( ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' ) )
+            // InternalRoom.g:5246:1: ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' )
             {
-            // InternalRoom.g:5185:1: ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' )
-            // InternalRoom.g:5185:2: () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}'
+            // InternalRoom.g:5246:1: ( () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}' )
+            // InternalRoom.g:5246:2: () otherlv_1= '{' ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )* otherlv_7= '}'
             {
-            // InternalRoom.g:5185:2: ()
-            // InternalRoom.g:5186:5: 
+            // InternalRoom.g:5246:2: ()
+            // InternalRoom.g:5247:5: 
             {
 
                     current = forceCreateModelElement(
@@ -12892,19 +13066,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_1=(Token)match(input,14,FOLLOW_107); 
+            otherlv_1=(Token)match(input,14,FOLLOW_108); 
 
                 	newLeafNode(otherlv_1, grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1());
                 
-            // InternalRoom.g:5195:1: ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )*
-            loop111:
+            // InternalRoom.g:5256:1: ( ( (lv_states_2_0= ruleState ) ) | ( (lv_trPoints_3_0= ruleTrPoint ) ) | ( (lv_chPoints_4_0= ruleChoicePoint ) ) | ( (lv_transitions_5_0= ruleTransition ) ) | ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) ) )*
+            loop113:
             do {
-                int alt111=6;
+                int alt113=6;
                 switch ( input.LA(1) ) {
                 case 81:
                 case 86:
                     {
-                    alt111=1;
+                    alt113=1;
                     }
                     break;
                 case 87:
@@ -12912,41 +13086,41 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 case 89:
                 case 90:
                     {
-                    alt111=2;
+                    alt113=2;
                     }
                     break;
                 case 91:
                     {
-                    alt111=3;
+                    alt113=3;
                     }
                     break;
                 case 92:
                     {
-                    alt111=4;
+                    alt113=4;
                     }
                     break;
                 case 99:
                     {
-                    alt111=5;
+                    alt113=5;
                     }
                     break;
 
                 }
 
-                switch (alt111) {
+                switch (alt113) {
             	case 1 :
-            	    // InternalRoom.g:5195:2: ( (lv_states_2_0= ruleState ) )
+            	    // InternalRoom.g:5256:2: ( (lv_states_2_0= ruleState ) )
             	    {
-            	    // InternalRoom.g:5195:2: ( (lv_states_2_0= ruleState ) )
-            	    // InternalRoom.g:5196:1: (lv_states_2_0= ruleState )
+            	    // InternalRoom.g:5256:2: ( (lv_states_2_0= ruleState ) )
+            	    // InternalRoom.g:5257:1: (lv_states_2_0= ruleState )
             	    {
-            	    // InternalRoom.g:5196:1: (lv_states_2_0= ruleState )
-            	    // InternalRoom.g:5197:3: lv_states_2_0= ruleState
+            	    // InternalRoom.g:5257:1: (lv_states_2_0= ruleState )
+            	    // InternalRoom.g:5258:3: lv_states_2_0= ruleState
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_states_2_0=ruleState();
 
             	    state._fsp--;
@@ -12972,18 +13146,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:5214:6: ( (lv_trPoints_3_0= ruleTrPoint ) )
+            	    // InternalRoom.g:5275:6: ( (lv_trPoints_3_0= ruleTrPoint ) )
             	    {
-            	    // InternalRoom.g:5214:6: ( (lv_trPoints_3_0= ruleTrPoint ) )
-            	    // InternalRoom.g:5215:1: (lv_trPoints_3_0= ruleTrPoint )
+            	    // InternalRoom.g:5275:6: ( (lv_trPoints_3_0= ruleTrPoint ) )
+            	    // InternalRoom.g:5276:1: (lv_trPoints_3_0= ruleTrPoint )
             	    {
-            	    // InternalRoom.g:5215:1: (lv_trPoints_3_0= ruleTrPoint )
-            	    // InternalRoom.g:5216:3: lv_trPoints_3_0= ruleTrPoint
+            	    // InternalRoom.g:5276:1: (lv_trPoints_3_0= ruleTrPoint )
+            	    // InternalRoom.g:5277:3: lv_trPoints_3_0= ruleTrPoint
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_trPoints_3_0=ruleTrPoint();
 
             	    state._fsp--;
@@ -13009,18 +13183,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:5233:6: ( (lv_chPoints_4_0= ruleChoicePoint ) )
+            	    // InternalRoom.g:5294:6: ( (lv_chPoints_4_0= ruleChoicePoint ) )
             	    {
-            	    // InternalRoom.g:5233:6: ( (lv_chPoints_4_0= ruleChoicePoint ) )
-            	    // InternalRoom.g:5234:1: (lv_chPoints_4_0= ruleChoicePoint )
+            	    // InternalRoom.g:5294:6: ( (lv_chPoints_4_0= ruleChoicePoint ) )
+            	    // InternalRoom.g:5295:1: (lv_chPoints_4_0= ruleChoicePoint )
             	    {
-            	    // InternalRoom.g:5234:1: (lv_chPoints_4_0= ruleChoicePoint )
-            	    // InternalRoom.g:5235:3: lv_chPoints_4_0= ruleChoicePoint
+            	    // InternalRoom.g:5295:1: (lv_chPoints_4_0= ruleChoicePoint )
+            	    // InternalRoom.g:5296:3: lv_chPoints_4_0= ruleChoicePoint
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_chPoints_4_0=ruleChoicePoint();
 
             	    state._fsp--;
@@ -13046,18 +13220,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 4 :
-            	    // InternalRoom.g:5252:6: ( (lv_transitions_5_0= ruleTransition ) )
+            	    // InternalRoom.g:5313:6: ( (lv_transitions_5_0= ruleTransition ) )
             	    {
-            	    // InternalRoom.g:5252:6: ( (lv_transitions_5_0= ruleTransition ) )
-            	    // InternalRoom.g:5253:1: (lv_transitions_5_0= ruleTransition )
+            	    // InternalRoom.g:5313:6: ( (lv_transitions_5_0= ruleTransition ) )
+            	    // InternalRoom.g:5314:1: (lv_transitions_5_0= ruleTransition )
             	    {
-            	    // InternalRoom.g:5253:1: (lv_transitions_5_0= ruleTransition )
-            	    // InternalRoom.g:5254:3: lv_transitions_5_0= ruleTransition
+            	    // InternalRoom.g:5314:1: (lv_transitions_5_0= ruleTransition )
+            	    // InternalRoom.g:5315:3: lv_transitions_5_0= ruleTransition
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_transitions_5_0=ruleTransition();
 
             	    state._fsp--;
@@ -13083,18 +13257,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 5 :
-            	    // InternalRoom.g:5271:6: ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) )
+            	    // InternalRoom.g:5332:6: ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) )
             	    {
-            	    // InternalRoom.g:5271:6: ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) )
-            	    // InternalRoom.g:5272:1: (lv_refinedTransitions_6_0= ruleRefinedTransition )
+            	    // InternalRoom.g:5332:6: ( (lv_refinedTransitions_6_0= ruleRefinedTransition ) )
+            	    // InternalRoom.g:5333:1: (lv_refinedTransitions_6_0= ruleRefinedTransition )
             	    {
-            	    // InternalRoom.g:5272:1: (lv_refinedTransitions_6_0= ruleRefinedTransition )
-            	    // InternalRoom.g:5273:3: lv_refinedTransitions_6_0= ruleRefinedTransition
+            	    // InternalRoom.g:5333:1: (lv_refinedTransitions_6_0= ruleRefinedTransition )
+            	    // InternalRoom.g:5334:3: lv_refinedTransitions_6_0= ruleRefinedTransition
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_refinedTransitions_6_0=ruleRefinedTransition();
 
             	    state._fsp--;
@@ -13121,7 +13295,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop111;
+            	    break loop113;
                 }
             } while (true);
 
@@ -13150,7 +13324,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateMachine"
-    // InternalRoom.g:5301:1: entryRuleStateMachine returns [EObject current=null] : iv_ruleStateMachine= ruleStateMachine EOF ;
+    // InternalRoom.g:5362:1: entryRuleStateMachine returns [EObject current=null] : iv_ruleStateMachine= ruleStateMachine EOF ;
     public final EObject entryRuleStateMachine() throws RecognitionException {
         EObject current = null;
 
@@ -13158,8 +13332,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5302:2: (iv_ruleStateMachine= ruleStateMachine EOF )
-            // InternalRoom.g:5303:2: iv_ruleStateMachine= ruleStateMachine EOF
+            // InternalRoom.g:5363:2: (iv_ruleStateMachine= ruleStateMachine EOF )
+            // InternalRoom.g:5364:2: iv_ruleStateMachine= ruleStateMachine EOF
             {
              newCompositeNode(grammarAccess.getStateMachineRule()); 
             pushFollow(FOLLOW_1);
@@ -13186,7 +13360,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateMachine"
-    // InternalRoom.g:5310:1: ruleStateMachine returns [EObject current=null] : ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' ) ;
+    // InternalRoom.g:5371:1: ruleStateMachine returns [EObject current=null] : ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' ) ;
     public final EObject ruleStateMachine() throws RecognitionException {
         EObject current = null;
 
@@ -13207,14 +13381,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5313:28: ( ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' ) )
-            // InternalRoom.g:5314:1: ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' )
+            // InternalRoom.g:5374:28: ( ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' ) )
+            // InternalRoom.g:5375:1: ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' )
             {
-            // InternalRoom.g:5314:1: ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' )
-            // InternalRoom.g:5314:2: () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}'
+            // InternalRoom.g:5375:1: ( () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}' )
+            // InternalRoom.g:5375:2: () otherlv_1= 'StateMachine' otherlv_2= '{' ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )* otherlv_8= '}'
             {
-            // InternalRoom.g:5314:2: ()
-            // InternalRoom.g:5315:5: 
+            // InternalRoom.g:5375:2: ()
+            // InternalRoom.g:5376:5: 
             {
 
                     current = forceCreateModelElement(
@@ -13228,19 +13402,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getStateMachineAccess().getStateMachineKeyword_1());
                 
-            otherlv_2=(Token)match(input,14,FOLLOW_107); 
+            otherlv_2=(Token)match(input,14,FOLLOW_108); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2());
                 
-            // InternalRoom.g:5328:1: ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )*
-            loop112:
+            // InternalRoom.g:5389:1: ( ( (lv_states_3_0= ruleState ) ) | ( (lv_trPoints_4_0= ruleTrPoint ) ) | ( (lv_chPoints_5_0= ruleChoicePoint ) ) | ( (lv_transitions_6_0= ruleTransition ) ) | ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) ) )*
+            loop114:
             do {
-                int alt112=6;
+                int alt114=6;
                 switch ( input.LA(1) ) {
                 case 81:
                 case 86:
                     {
-                    alt112=1;
+                    alt114=1;
                     }
                     break;
                 case 87:
@@ -13248,41 +13422,41 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 case 89:
                 case 90:
                     {
-                    alt112=2;
+                    alt114=2;
                     }
                     break;
                 case 91:
                     {
-                    alt112=3;
+                    alt114=3;
                     }
                     break;
                 case 92:
                     {
-                    alt112=4;
+                    alt114=4;
                     }
                     break;
                 case 99:
                     {
-                    alt112=5;
+                    alt114=5;
                     }
                     break;
 
                 }
 
-                switch (alt112) {
+                switch (alt114) {
             	case 1 :
-            	    // InternalRoom.g:5328:2: ( (lv_states_3_0= ruleState ) )
+            	    // InternalRoom.g:5389:2: ( (lv_states_3_0= ruleState ) )
             	    {
-            	    // InternalRoom.g:5328:2: ( (lv_states_3_0= ruleState ) )
-            	    // InternalRoom.g:5329:1: (lv_states_3_0= ruleState )
+            	    // InternalRoom.g:5389:2: ( (lv_states_3_0= ruleState ) )
+            	    // InternalRoom.g:5390:1: (lv_states_3_0= ruleState )
             	    {
-            	    // InternalRoom.g:5329:1: (lv_states_3_0= ruleState )
-            	    // InternalRoom.g:5330:3: lv_states_3_0= ruleState
+            	    // InternalRoom.g:5390:1: (lv_states_3_0= ruleState )
+            	    // InternalRoom.g:5391:3: lv_states_3_0= ruleState
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_states_3_0=ruleState();
 
             	    state._fsp--;
@@ -13308,18 +13482,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 2 :
-            	    // InternalRoom.g:5347:6: ( (lv_trPoints_4_0= ruleTrPoint ) )
+            	    // InternalRoom.g:5408:6: ( (lv_trPoints_4_0= ruleTrPoint ) )
             	    {
-            	    // InternalRoom.g:5347:6: ( (lv_trPoints_4_0= ruleTrPoint ) )
-            	    // InternalRoom.g:5348:1: (lv_trPoints_4_0= ruleTrPoint )
+            	    // InternalRoom.g:5408:6: ( (lv_trPoints_4_0= ruleTrPoint ) )
+            	    // InternalRoom.g:5409:1: (lv_trPoints_4_0= ruleTrPoint )
             	    {
-            	    // InternalRoom.g:5348:1: (lv_trPoints_4_0= ruleTrPoint )
-            	    // InternalRoom.g:5349:3: lv_trPoints_4_0= ruleTrPoint
+            	    // InternalRoom.g:5409:1: (lv_trPoints_4_0= ruleTrPoint )
+            	    // InternalRoom.g:5410:3: lv_trPoints_4_0= ruleTrPoint
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_trPoints_4_0=ruleTrPoint();
 
             	    state._fsp--;
@@ -13345,18 +13519,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 3 :
-            	    // InternalRoom.g:5366:6: ( (lv_chPoints_5_0= ruleChoicePoint ) )
+            	    // InternalRoom.g:5427:6: ( (lv_chPoints_5_0= ruleChoicePoint ) )
             	    {
-            	    // InternalRoom.g:5366:6: ( (lv_chPoints_5_0= ruleChoicePoint ) )
-            	    // InternalRoom.g:5367:1: (lv_chPoints_5_0= ruleChoicePoint )
+            	    // InternalRoom.g:5427:6: ( (lv_chPoints_5_0= ruleChoicePoint ) )
+            	    // InternalRoom.g:5428:1: (lv_chPoints_5_0= ruleChoicePoint )
             	    {
-            	    // InternalRoom.g:5367:1: (lv_chPoints_5_0= ruleChoicePoint )
-            	    // InternalRoom.g:5368:3: lv_chPoints_5_0= ruleChoicePoint
+            	    // InternalRoom.g:5428:1: (lv_chPoints_5_0= ruleChoicePoint )
+            	    // InternalRoom.g:5429:3: lv_chPoints_5_0= ruleChoicePoint
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_chPoints_5_0=ruleChoicePoint();
 
             	    state._fsp--;
@@ -13382,18 +13556,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 4 :
-            	    // InternalRoom.g:5385:6: ( (lv_transitions_6_0= ruleTransition ) )
+            	    // InternalRoom.g:5446:6: ( (lv_transitions_6_0= ruleTransition ) )
             	    {
-            	    // InternalRoom.g:5385:6: ( (lv_transitions_6_0= ruleTransition ) )
-            	    // InternalRoom.g:5386:1: (lv_transitions_6_0= ruleTransition )
+            	    // InternalRoom.g:5446:6: ( (lv_transitions_6_0= ruleTransition ) )
+            	    // InternalRoom.g:5447:1: (lv_transitions_6_0= ruleTransition )
             	    {
-            	    // InternalRoom.g:5386:1: (lv_transitions_6_0= ruleTransition )
-            	    // InternalRoom.g:5387:3: lv_transitions_6_0= ruleTransition
+            	    // InternalRoom.g:5447:1: (lv_transitions_6_0= ruleTransition )
+            	    // InternalRoom.g:5448:3: lv_transitions_6_0= ruleTransition
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_transitions_6_0=ruleTransition();
 
             	    state._fsp--;
@@ -13419,18 +13593,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    }
             	    break;
             	case 5 :
-            	    // InternalRoom.g:5404:6: ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) )
+            	    // InternalRoom.g:5465:6: ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) )
             	    {
-            	    // InternalRoom.g:5404:6: ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) )
-            	    // InternalRoom.g:5405:1: (lv_refinedTransitions_7_0= ruleRefinedTransition )
+            	    // InternalRoom.g:5465:6: ( (lv_refinedTransitions_7_0= ruleRefinedTransition ) )
+            	    // InternalRoom.g:5466:1: (lv_refinedTransitions_7_0= ruleRefinedTransition )
             	    {
-            	    // InternalRoom.g:5405:1: (lv_refinedTransitions_7_0= ruleRefinedTransition )
-            	    // InternalRoom.g:5406:3: lv_refinedTransitions_7_0= ruleRefinedTransition
+            	    // InternalRoom.g:5466:1: (lv_refinedTransitions_7_0= ruleRefinedTransition )
+            	    // InternalRoom.g:5467:3: lv_refinedTransitions_7_0= ruleRefinedTransition
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); 
             	    	    
-            	    pushFollow(FOLLOW_107);
+            	    pushFollow(FOLLOW_108);
             	    lv_refinedTransitions_7_0=ruleRefinedTransition();
 
             	    state._fsp--;
@@ -13457,7 +13631,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop112;
+            	    break loop114;
                 }
             } while (true);
 
@@ -13486,7 +13660,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleState"
-    // InternalRoom.g:5434:1: entryRuleState returns [EObject current=null] : iv_ruleState= ruleState EOF ;
+    // InternalRoom.g:5495:1: entryRuleState returns [EObject current=null] : iv_ruleState= ruleState EOF ;
     public final EObject entryRuleState() throws RecognitionException {
         EObject current = null;
 
@@ -13494,8 +13668,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5435:2: (iv_ruleState= ruleState EOF )
-            // InternalRoom.g:5436:2: iv_ruleState= ruleState EOF
+            // InternalRoom.g:5496:2: (iv_ruleState= ruleState EOF )
+            // InternalRoom.g:5497:2: iv_ruleState= ruleState EOF
             {
              newCompositeNode(grammarAccess.getStateRule()); 
             pushFollow(FOLLOW_1);
@@ -13522,7 +13696,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleState"
-    // InternalRoom.g:5443:1: ruleState returns [EObject current=null] : (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState ) ;
+    // InternalRoom.g:5504:1: ruleState returns [EObject current=null] : (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState ) ;
     public final EObject ruleState() throws RecognitionException {
         EObject current = null;
 
@@ -13534,28 +13708,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5446:28: ( (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState ) )
-            // InternalRoom.g:5447:1: (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState )
+            // InternalRoom.g:5507:28: ( (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState ) )
+            // InternalRoom.g:5508:1: (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState )
             {
-            // InternalRoom.g:5447:1: (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState )
-            int alt113=2;
-            int LA113_0 = input.LA(1);
+            // InternalRoom.g:5508:1: (this_SimpleState_0= ruleSimpleState | this_RefinedState_1= ruleRefinedState )
+            int alt115=2;
+            int LA115_0 = input.LA(1);
 
-            if ( (LA113_0==81) ) {
-                alt113=1;
+            if ( (LA115_0==81) ) {
+                alt115=1;
             }
-            else if ( (LA113_0==86) ) {
-                alt113=2;
+            else if ( (LA115_0==86) ) {
+                alt115=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 113, 0, input);
+                    new NoViableAltException("", 115, 0, input);
 
                 throw nvae;
             }
-            switch (alt113) {
+            switch (alt115) {
                 case 1 :
-                    // InternalRoom.g:5448:5: this_SimpleState_0= ruleSimpleState
+                    // InternalRoom.g:5509:5: this_SimpleState_0= ruleSimpleState
                     {
                      
                             newCompositeNode(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); 
@@ -13573,7 +13747,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5458:5: this_RefinedState_1= ruleRefinedState
+                    // InternalRoom.g:5519:5: this_RefinedState_1= ruleRefinedState
                     {
                      
                             newCompositeNode(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); 
@@ -13611,7 +13785,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSimpleState"
-    // InternalRoom.g:5474:1: entryRuleSimpleState returns [EObject current=null] : iv_ruleSimpleState= ruleSimpleState EOF ;
+    // InternalRoom.g:5535:1: entryRuleSimpleState returns [EObject current=null] : iv_ruleSimpleState= ruleSimpleState EOF ;
     public final EObject entryRuleSimpleState() throws RecognitionException {
         EObject current = null;
 
@@ -13619,8 +13793,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5475:2: (iv_ruleSimpleState= ruleSimpleState EOF )
-            // InternalRoom.g:5476:2: iv_ruleSimpleState= ruleSimpleState EOF
+            // InternalRoom.g:5536:2: (iv_ruleSimpleState= ruleSimpleState EOF )
+            // InternalRoom.g:5537:2: iv_ruleSimpleState= ruleSimpleState EOF
             {
              newCompositeNode(grammarAccess.getSimpleStateRule()); 
             pushFollow(FOLLOW_1);
@@ -13647,7 +13821,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSimpleState"
-    // InternalRoom.g:5483:1: ruleSimpleState returns [EObject current=null] : (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? ) ;
+    // InternalRoom.g:5544:1: ruleSimpleState returns [EObject current=null] : (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? ) ;
     public final EObject ruleSimpleState() throws RecognitionException {
         EObject current = null;
 
@@ -13673,23 +13847,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5486:28: ( (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? ) )
-            // InternalRoom.g:5487:1: (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? )
+            // InternalRoom.g:5547:28: ( (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? ) )
+            // InternalRoom.g:5548:1: (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? )
             {
-            // InternalRoom.g:5487:1: (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? )
-            // InternalRoom.g:5487:3: otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )?
+            // InternalRoom.g:5548:1: (otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )? )
+            // InternalRoom.g:5548:3: otherlv_0= 'State' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )?
             {
             otherlv_0=(Token)match(input,81,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getSimpleStateAccess().getStateKeyword_0());
                 
-            // InternalRoom.g:5491:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:5492:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:5552:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:5553:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:5492:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:5493:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:5553:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:5554:3: lv_name_1_0= RULE_ID
             {
-            lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_108); 
+            lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_109); 
 
             			newLeafNode(lv_name_1_0, grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); 
             		
@@ -13709,24 +13883,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5509:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt114=2;
-            int LA114_0 = input.LA(1);
+            // InternalRoom.g:5570:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt116=2;
+            int LA116_0 = input.LA(1);
 
-            if ( (LA114_0==34) ) {
-                alt114=1;
+            if ( (LA116_0==34) ) {
+                alt116=1;
             }
-            switch (alt114) {
+            switch (alt116) {
                 case 1 :
-                    // InternalRoom.g:5510:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:5571:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:5510:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:5511:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:5571:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:5572:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
                     	    
-                    pushFollow(FOLLOW_96);
+                    pushFollow(FOLLOW_97);
                     lv_docu_2_0=ruleDocumentation();
 
                     state._fsp--;
@@ -13751,46 +13925,46 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5527:3: (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )?
-            int alt119=2;
-            int LA119_0 = input.LA(1);
+            // InternalRoom.g:5588:3: (otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )?
+            int alt121=2;
+            int LA121_0 = input.LA(1);
 
-            if ( (LA119_0==14) ) {
-                alt119=1;
+            if ( (LA121_0==14) ) {
+                alt121=1;
             }
-            switch (alt119) {
+            switch (alt121) {
                 case 1 :
-                    // InternalRoom.g:5527:5: otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}'
+                    // InternalRoom.g:5588:5: otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}'
                     {
-                    otherlv_3=(Token)match(input,14,FOLLOW_109); 
+                    otherlv_3=(Token)match(input,14,FOLLOW_110); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0());
                         
-                    // InternalRoom.g:5531:1: (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )?
-                    int alt115=2;
-                    int LA115_0 = input.LA(1);
+                    // InternalRoom.g:5592:1: (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )?
+                    int alt117=2;
+                    int LA117_0 = input.LA(1);
 
-                    if ( (LA115_0==82) ) {
-                        alt115=1;
+                    if ( (LA117_0==82) ) {
+                        alt117=1;
                     }
-                    switch (alt115) {
+                    switch (alt117) {
                         case 1 :
-                            // InternalRoom.g:5531:3: otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) )
+                            // InternalRoom.g:5592:3: otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) )
                             {
-                            otherlv_4=(Token)match(input,82,FOLLOW_110); 
+                            otherlv_4=(Token)match(input,82,FOLLOW_111); 
 
                                 	newLeafNode(otherlv_4, grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0());
                                 
-                            // InternalRoom.g:5535:1: ( (lv_entryCode_5_0= ruleDetailCode ) )
-                            // InternalRoom.g:5536:1: (lv_entryCode_5_0= ruleDetailCode )
+                            // InternalRoom.g:5596:1: ( (lv_entryCode_5_0= ruleDetailCode ) )
+                            // InternalRoom.g:5597:1: (lv_entryCode_5_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:5536:1: (lv_entryCode_5_0= ruleDetailCode )
-                            // InternalRoom.g:5537:3: lv_entryCode_5_0= ruleDetailCode
+                            // InternalRoom.g:5597:1: (lv_entryCode_5_0= ruleDetailCode )
+                            // InternalRoom.g:5598:3: lv_entryCode_5_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); 
                             	    
-                            pushFollow(FOLLOW_111);
+                            pushFollow(FOLLOW_112);
                             lv_entryCode_5_0=ruleDetailCode();
 
                             state._fsp--;
@@ -13818,31 +13992,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:5553:4: (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )?
-                    int alt116=2;
-                    int LA116_0 = input.LA(1);
+                    // InternalRoom.g:5614:4: (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )?
+                    int alt118=2;
+                    int LA118_0 = input.LA(1);
 
-                    if ( (LA116_0==83) ) {
-                        alt116=1;
+                    if ( (LA118_0==83) ) {
+                        alt118=1;
                     }
-                    switch (alt116) {
+                    switch (alt118) {
                         case 1 :
-                            // InternalRoom.g:5553:6: otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) )
+                            // InternalRoom.g:5614:6: otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) )
                             {
-                            otherlv_6=(Token)match(input,83,FOLLOW_112); 
+                            otherlv_6=(Token)match(input,83,FOLLOW_113); 
 
                                 	newLeafNode(otherlv_6, grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0());
                                 
-                            // InternalRoom.g:5557:1: ( (lv_exitCode_7_0= ruleDetailCode ) )
-                            // InternalRoom.g:5558:1: (lv_exitCode_7_0= ruleDetailCode )
+                            // InternalRoom.g:5618:1: ( (lv_exitCode_7_0= ruleDetailCode ) )
+                            // InternalRoom.g:5619:1: (lv_exitCode_7_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:5558:1: (lv_exitCode_7_0= ruleDetailCode )
-                            // InternalRoom.g:5559:3: lv_exitCode_7_0= ruleDetailCode
+                            // InternalRoom.g:5619:1: (lv_exitCode_7_0= ruleDetailCode )
+                            // InternalRoom.g:5620:3: lv_exitCode_7_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); 
                             	    
-                            pushFollow(FOLLOW_113);
+                            pushFollow(FOLLOW_114);
                             lv_exitCode_7_0=ruleDetailCode();
 
                             state._fsp--;
@@ -13870,31 +14044,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:5575:4: (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )?
-                    int alt117=2;
-                    int LA117_0 = input.LA(1);
+                    // InternalRoom.g:5636:4: (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )?
+                    int alt119=2;
+                    int LA119_0 = input.LA(1);
 
-                    if ( (LA117_0==84) ) {
-                        alt117=1;
+                    if ( (LA119_0==84) ) {
+                        alt119=1;
                     }
-                    switch (alt117) {
+                    switch (alt119) {
                         case 1 :
-                            // InternalRoom.g:5575:6: otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:5636:6: otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) )
                             {
-                            otherlv_8=(Token)match(input,84,FOLLOW_114); 
+                            otherlv_8=(Token)match(input,84,FOLLOW_115); 
 
                                 	newLeafNode(otherlv_8, grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0());
                                 
-                            // InternalRoom.g:5579:1: ( (lv_doCode_9_0= ruleDetailCode ) )
-                            // InternalRoom.g:5580:1: (lv_doCode_9_0= ruleDetailCode )
+                            // InternalRoom.g:5640:1: ( (lv_doCode_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:5641:1: (lv_doCode_9_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:5580:1: (lv_doCode_9_0= ruleDetailCode )
-                            // InternalRoom.g:5581:3: lv_doCode_9_0= ruleDetailCode
+                            // InternalRoom.g:5641:1: (lv_doCode_9_0= ruleDetailCode )
+                            // InternalRoom.g:5642:3: lv_doCode_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); 
                             	    
-                            pushFollow(FOLLOW_115);
+                            pushFollow(FOLLOW_116);
                             lv_doCode_9_0=ruleDetailCode();
 
                             state._fsp--;
@@ -13922,26 +14096,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:5597:4: (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )?
-                    int alt118=2;
-                    int LA118_0 = input.LA(1);
+                    // InternalRoom.g:5658:4: (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )?
+                    int alt120=2;
+                    int LA120_0 = input.LA(1);
 
-                    if ( (LA118_0==85) ) {
-                        alt118=1;
+                    if ( (LA120_0==85) ) {
+                        alt120=1;
                     }
-                    switch (alt118) {
+                    switch (alt120) {
                         case 1 :
-                            // InternalRoom.g:5597:6: otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) )
+                            // InternalRoom.g:5658:6: otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) )
                             {
                             otherlv_10=(Token)match(input,85,FOLLOW_5); 
 
                                 	newLeafNode(otherlv_10, grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0());
                                 
-                            // InternalRoom.g:5601:1: ( (lv_subgraph_11_0= ruleStateGraph ) )
-                            // InternalRoom.g:5602:1: (lv_subgraph_11_0= ruleStateGraph )
+                            // InternalRoom.g:5662:1: ( (lv_subgraph_11_0= ruleStateGraph ) )
+                            // InternalRoom.g:5663:1: (lv_subgraph_11_0= ruleStateGraph )
                             {
-                            // InternalRoom.g:5602:1: (lv_subgraph_11_0= ruleStateGraph )
-                            // InternalRoom.g:5603:3: lv_subgraph_11_0= ruleStateGraph
+                            // InternalRoom.g:5663:1: (lv_subgraph_11_0= ruleStateGraph )
+                            // InternalRoom.g:5664:3: lv_subgraph_11_0= ruleStateGraph
                             {
                              
                             	        newCompositeNode(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); 
@@ -14005,7 +14179,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefinedState"
-    // InternalRoom.g:5631:1: entryRuleRefinedState returns [EObject current=null] : iv_ruleRefinedState= ruleRefinedState EOF ;
+    // InternalRoom.g:5692:1: entryRuleRefinedState returns [EObject current=null] : iv_ruleRefinedState= ruleRefinedState EOF ;
     public final EObject entryRuleRefinedState() throws RecognitionException {
         EObject current = null;
 
@@ -14013,8 +14187,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5632:2: (iv_ruleRefinedState= ruleRefinedState EOF )
-            // InternalRoom.g:5633:2: iv_ruleRefinedState= ruleRefinedState EOF
+            // InternalRoom.g:5693:2: (iv_ruleRefinedState= ruleRefinedState EOF )
+            // InternalRoom.g:5694:2: iv_ruleRefinedState= ruleRefinedState EOF
             {
              newCompositeNode(grammarAccess.getRefinedStateRule()); 
             pushFollow(FOLLOW_1);
@@ -14041,7 +14215,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefinedState"
-    // InternalRoom.g:5640:1: ruleRefinedState returns [EObject current=null] : (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' ) ;
+    // InternalRoom.g:5701:1: ruleRefinedState returns [EObject current=null] : (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' ) ;
     public final EObject ruleRefinedState() throws RecognitionException {
         EObject current = null;
 
@@ -14066,21 +14240,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5643:28: ( (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' ) )
-            // InternalRoom.g:5644:1: (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:5704:28: ( (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' ) )
+            // InternalRoom.g:5705:1: (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )
             {
-            // InternalRoom.g:5644:1: (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )
-            // InternalRoom.g:5644:3: otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}'
+            // InternalRoom.g:5705:1: (otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:5705:3: otherlv_0= 'RefinedState' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )? (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )? (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )? (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )? otherlv_12= '}'
             {
             otherlv_0=(Token)match(input,86,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0());
                 
-            // InternalRoom.g:5648:1: ( ( ruleFQN ) )
-            // InternalRoom.g:5649:1: ( ruleFQN )
+            // InternalRoom.g:5709:1: ( ( ruleFQN ) )
+            // InternalRoom.g:5710:1: ( ruleFQN )
             {
-            // InternalRoom.g:5649:1: ( ruleFQN )
-            // InternalRoom.g:5650:3: ruleFQN
+            // InternalRoom.g:5710:1: ( ruleFQN )
+            // InternalRoom.g:5711:3: ruleFQN
             {
 
             			if (current==null) {
@@ -14104,19 +14278,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5663:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt120=2;
-            int LA120_0 = input.LA(1);
+            // InternalRoom.g:5724:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt122=2;
+            int LA122_0 = input.LA(1);
 
-            if ( (LA120_0==34) ) {
-                alt120=1;
+            if ( (LA122_0==34) ) {
+                alt122=1;
             }
-            switch (alt120) {
+            switch (alt122) {
                 case 1 :
-                    // InternalRoom.g:5664:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:5725:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:5664:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:5665:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:5725:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:5726:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -14146,35 +14320,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,14,FOLLOW_109); 
+            otherlv_3=(Token)match(input,14,FOLLOW_110); 
 
                 	newLeafNode(otherlv_3, grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3());
                 
-            // InternalRoom.g:5685:1: (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )?
-            int alt121=2;
-            int LA121_0 = input.LA(1);
+            // InternalRoom.g:5746:1: (otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) ) )?
+            int alt123=2;
+            int LA123_0 = input.LA(1);
 
-            if ( (LA121_0==82) ) {
-                alt121=1;
+            if ( (LA123_0==82) ) {
+                alt123=1;
             }
-            switch (alt121) {
+            switch (alt123) {
                 case 1 :
-                    // InternalRoom.g:5685:3: otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) )
+                    // InternalRoom.g:5746:3: otherlv_4= 'entry' ( (lv_entryCode_5_0= ruleDetailCode ) )
                     {
-                    otherlv_4=(Token)match(input,82,FOLLOW_110); 
+                    otherlv_4=(Token)match(input,82,FOLLOW_111); 
 
                         	newLeafNode(otherlv_4, grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0());
                         
-                    // InternalRoom.g:5689:1: ( (lv_entryCode_5_0= ruleDetailCode ) )
-                    // InternalRoom.g:5690:1: (lv_entryCode_5_0= ruleDetailCode )
+                    // InternalRoom.g:5750:1: ( (lv_entryCode_5_0= ruleDetailCode ) )
+                    // InternalRoom.g:5751:1: (lv_entryCode_5_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:5690:1: (lv_entryCode_5_0= ruleDetailCode )
-                    // InternalRoom.g:5691:3: lv_entryCode_5_0= ruleDetailCode
+                    // InternalRoom.g:5751:1: (lv_entryCode_5_0= ruleDetailCode )
+                    // InternalRoom.g:5752:3: lv_entryCode_5_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); 
                     	    
-                    pushFollow(FOLLOW_111);
+                    pushFollow(FOLLOW_112);
                     lv_entryCode_5_0=ruleDetailCode();
 
                     state._fsp--;
@@ -14202,31 +14376,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5707:4: (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )?
-            int alt122=2;
-            int LA122_0 = input.LA(1);
+            // InternalRoom.g:5768:4: (otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) ) )?
+            int alt124=2;
+            int LA124_0 = input.LA(1);
 
-            if ( (LA122_0==83) ) {
-                alt122=1;
+            if ( (LA124_0==83) ) {
+                alt124=1;
             }
-            switch (alt122) {
+            switch (alt124) {
                 case 1 :
-                    // InternalRoom.g:5707:6: otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) )
+                    // InternalRoom.g:5768:6: otherlv_6= 'exit' ( (lv_exitCode_7_0= ruleDetailCode ) )
                     {
-                    otherlv_6=(Token)match(input,83,FOLLOW_112); 
+                    otherlv_6=(Token)match(input,83,FOLLOW_113); 
 
                         	newLeafNode(otherlv_6, grammarAccess.getRefinedStateAccess().getExitKeyword_5_0());
                         
-                    // InternalRoom.g:5711:1: ( (lv_exitCode_7_0= ruleDetailCode ) )
-                    // InternalRoom.g:5712:1: (lv_exitCode_7_0= ruleDetailCode )
+                    // InternalRoom.g:5772:1: ( (lv_exitCode_7_0= ruleDetailCode ) )
+                    // InternalRoom.g:5773:1: (lv_exitCode_7_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:5712:1: (lv_exitCode_7_0= ruleDetailCode )
-                    // InternalRoom.g:5713:3: lv_exitCode_7_0= ruleDetailCode
+                    // InternalRoom.g:5773:1: (lv_exitCode_7_0= ruleDetailCode )
+                    // InternalRoom.g:5774:3: lv_exitCode_7_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); 
                     	    
-                    pushFollow(FOLLOW_113);
+                    pushFollow(FOLLOW_114);
                     lv_exitCode_7_0=ruleDetailCode();
 
                     state._fsp--;
@@ -14254,31 +14428,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5729:4: (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )?
-            int alt123=2;
-            int LA123_0 = input.LA(1);
+            // InternalRoom.g:5790:4: (otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) ) )?
+            int alt125=2;
+            int LA125_0 = input.LA(1);
 
-            if ( (LA123_0==84) ) {
-                alt123=1;
+            if ( (LA125_0==84) ) {
+                alt125=1;
             }
-            switch (alt123) {
+            switch (alt125) {
                 case 1 :
-                    // InternalRoom.g:5729:6: otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) )
+                    // InternalRoom.g:5790:6: otherlv_8= 'do' ( (lv_doCode_9_0= ruleDetailCode ) )
                     {
-                    otherlv_8=(Token)match(input,84,FOLLOW_114); 
+                    otherlv_8=(Token)match(input,84,FOLLOW_115); 
 
                         	newLeafNode(otherlv_8, grammarAccess.getRefinedStateAccess().getDoKeyword_6_0());
                         
-                    // InternalRoom.g:5733:1: ( (lv_doCode_9_0= ruleDetailCode ) )
-                    // InternalRoom.g:5734:1: (lv_doCode_9_0= ruleDetailCode )
+                    // InternalRoom.g:5794:1: ( (lv_doCode_9_0= ruleDetailCode ) )
+                    // InternalRoom.g:5795:1: (lv_doCode_9_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:5734:1: (lv_doCode_9_0= ruleDetailCode )
-                    // InternalRoom.g:5735:3: lv_doCode_9_0= ruleDetailCode
+                    // InternalRoom.g:5795:1: (lv_doCode_9_0= ruleDetailCode )
+                    // InternalRoom.g:5796:3: lv_doCode_9_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); 
                     	    
-                    pushFollow(FOLLOW_115);
+                    pushFollow(FOLLOW_116);
                     lv_doCode_9_0=ruleDetailCode();
 
                     state._fsp--;
@@ -14306,26 +14480,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:5751:4: (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )?
-            int alt124=2;
-            int LA124_0 = input.LA(1);
+            // InternalRoom.g:5812:4: (otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) ) )?
+            int alt126=2;
+            int LA126_0 = input.LA(1);
 
-            if ( (LA124_0==85) ) {
-                alt124=1;
+            if ( (LA126_0==85) ) {
+                alt126=1;
             }
-            switch (alt124) {
+            switch (alt126) {
                 case 1 :
-                    // InternalRoom.g:5751:6: otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) )
+                    // InternalRoom.g:5812:6: otherlv_10= 'subgraph' ( (lv_subgraph_11_0= ruleStateGraph ) )
                     {
                     otherlv_10=(Token)match(input,85,FOLLOW_5); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0());
                         
-                    // InternalRoom.g:5755:1: ( (lv_subgraph_11_0= ruleStateGraph ) )
-                    // InternalRoom.g:5756:1: (lv_subgraph_11_0= ruleStateGraph )
+                    // InternalRoom.g:5816:1: ( (lv_subgraph_11_0= ruleStateGraph ) )
+                    // InternalRoom.g:5817:1: (lv_subgraph_11_0= ruleStateGraph )
                     {
-                    // InternalRoom.g:5756:1: (lv_subgraph_11_0= ruleStateGraph )
-                    // InternalRoom.g:5757:3: lv_subgraph_11_0= ruleStateGraph
+                    // InternalRoom.g:5817:1: (lv_subgraph_11_0= ruleStateGraph )
+                    // InternalRoom.g:5818:3: lv_subgraph_11_0= ruleStateGraph
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); 
@@ -14383,7 +14557,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDetailCode"
-    // InternalRoom.g:5785:1: entryRuleDetailCode returns [EObject current=null] : iv_ruleDetailCode= ruleDetailCode EOF ;
+    // InternalRoom.g:5846:1: entryRuleDetailCode returns [EObject current=null] : iv_ruleDetailCode= ruleDetailCode EOF ;
     public final EObject entryRuleDetailCode() throws RecognitionException {
         EObject current = null;
 
@@ -14391,8 +14565,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5786:2: (iv_ruleDetailCode= ruleDetailCode EOF )
-            // InternalRoom.g:5787:2: iv_ruleDetailCode= ruleDetailCode EOF
+            // InternalRoom.g:5847:2: (iv_ruleDetailCode= ruleDetailCode EOF )
+            // InternalRoom.g:5848:2: iv_ruleDetailCode= ruleDetailCode EOF
             {
              newCompositeNode(grammarAccess.getDetailCodeRule()); 
             pushFollow(FOLLOW_1);
@@ -14419,7 +14593,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDetailCode"
-    // InternalRoom.g:5794:1: ruleDetailCode returns [EObject current=null] : ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) ) ;
+    // InternalRoom.g:5855:1: ruleDetailCode returns [EObject current=null] : ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) ) ;
     public final EObject ruleDetailCode() throws RecognitionException {
         EObject current = null;
 
@@ -14431,34 +14605,34 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5797:28: ( ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) ) )
-            // InternalRoom.g:5798:1: ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) )
+            // InternalRoom.g:5858:28: ( ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) ) )
+            // InternalRoom.g:5859:1: ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) )
             {
-            // InternalRoom.g:5798:1: ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) )
-            int alt127=2;
-            int LA127_0 = input.LA(1);
+            // InternalRoom.g:5859:1: ( ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? ) | ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' ) )
+            int alt129=2;
+            int LA129_0 = input.LA(1);
 
-            if ( (LA127_0==EOF||LA127_0==RULE_CC_STRING||LA127_0==15||(LA127_0>=31 && LA127_0<=33)||(LA127_0>=36 && LA127_0<=37)||(LA127_0>=40 && LA127_0<=41)||(LA127_0>=43 && LA127_0<=45)||LA127_0==47||LA127_0==53||(LA127_0>=59 && LA127_0<=63)||(LA127_0>=67 && LA127_0<=68)||LA127_0==70||LA127_0==74||LA127_0==77||LA127_0==80||(LA127_0>=83 && LA127_0<=85)||LA127_0==94||(LA127_0>=104 && LA127_0<=105)||LA127_0==111||LA127_0==127) ) {
-                alt127=1;
+            if ( (LA129_0==EOF||LA129_0==RULE_CC_STRING||LA129_0==15||(LA129_0>=31 && LA129_0<=33)||(LA129_0>=36 && LA129_0<=37)||(LA129_0>=40 && LA129_0<=41)||(LA129_0>=43 && LA129_0<=45)||LA129_0==47||LA129_0==53||(LA129_0>=59 && LA129_0<=63)||(LA129_0>=67 && LA129_0<=68)||LA129_0==70||LA129_0==74||LA129_0==77||LA129_0==80||(LA129_0>=83 && LA129_0<=85)||LA129_0==94||(LA129_0>=104 && LA129_0<=105)||LA129_0==111||LA129_0==127) ) {
+                alt129=1;
             }
-            else if ( (LA127_0==14) ) {
-                alt127=2;
+            else if ( (LA129_0==14) ) {
+                alt129=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 127, 0, input);
+                    new NoViableAltException("", 129, 0, input);
 
                 throw nvae;
             }
-            switch (alt127) {
+            switch (alt129) {
                 case 1 :
-                    // InternalRoom.g:5798:2: ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? )
+                    // InternalRoom.g:5859:2: ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? )
                     {
-                    // InternalRoom.g:5798:2: ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? )
-                    // InternalRoom.g:5798:3: () ( (lv_lines_1_0= RULE_CC_STRING ) )?
+                    // InternalRoom.g:5859:2: ( () ( (lv_lines_1_0= RULE_CC_STRING ) )? )
+                    // InternalRoom.g:5859:3: () ( (lv_lines_1_0= RULE_CC_STRING ) )?
                     {
-                    // InternalRoom.g:5798:3: ()
-                    // InternalRoom.g:5799:5: 
+                    // InternalRoom.g:5859:3: ()
+                    // InternalRoom.g:5860:5: 
                     {
 
                             current = forceCreateModelElement(
@@ -14468,19 +14642,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:5804:2: ( (lv_lines_1_0= RULE_CC_STRING ) )?
-                    int alt125=2;
-                    int LA125_0 = input.LA(1);
+                    // InternalRoom.g:5865:2: ( (lv_lines_1_0= RULE_CC_STRING ) )?
+                    int alt127=2;
+                    int LA127_0 = input.LA(1);
 
-                    if ( (LA125_0==RULE_CC_STRING) ) {
-                        alt125=1;
+                    if ( (LA127_0==RULE_CC_STRING) ) {
+                        alt127=1;
                     }
-                    switch (alt125) {
+                    switch (alt127) {
                         case 1 :
-                            // InternalRoom.g:5805:1: (lv_lines_1_0= RULE_CC_STRING )
+                            // InternalRoom.g:5866:1: (lv_lines_1_0= RULE_CC_STRING )
                             {
-                            // InternalRoom.g:5805:1: (lv_lines_1_0= RULE_CC_STRING )
-                            // InternalRoom.g:5806:3: lv_lines_1_0= RULE_CC_STRING
+                            // InternalRoom.g:5866:1: (lv_lines_1_0= RULE_CC_STRING )
+                            // InternalRoom.g:5867:3: lv_lines_1_0= RULE_CC_STRING
                             {
                             lv_lines_1_0=(Token)match(input,RULE_CC_STRING,FOLLOW_2); 
 
@@ -14512,18 +14686,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5823:6: ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' )
+                    // InternalRoom.g:5884:6: ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' )
                     {
-                    // InternalRoom.g:5823:6: ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' )
-                    // InternalRoom.g:5823:7: ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}'
+                    // InternalRoom.g:5884:6: ( ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}' )
+                    // InternalRoom.g:5884:7: ( (lv_used_2_0= '{' ) ) ( (lv_lines_3_0= RULE_STRING ) )* otherlv_4= '}'
                     {
-                    // InternalRoom.g:5823:7: ( (lv_used_2_0= '{' ) )
-                    // InternalRoom.g:5824:1: (lv_used_2_0= '{' )
+                    // InternalRoom.g:5884:7: ( (lv_used_2_0= '{' ) )
+                    // InternalRoom.g:5885:1: (lv_used_2_0= '{' )
                     {
-                    // InternalRoom.g:5824:1: (lv_used_2_0= '{' )
-                    // InternalRoom.g:5825:3: lv_used_2_0= '{'
+                    // InternalRoom.g:5885:1: (lv_used_2_0= '{' )
+                    // InternalRoom.g:5886:3: lv_used_2_0= '{'
                     {
-                    lv_used_2_0=(Token)match(input,14,FOLLOW_116); 
+                    lv_used_2_0=(Token)match(input,14,FOLLOW_117); 
 
                             newLeafNode(lv_used_2_0, grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0());
                         
@@ -14539,25 +14713,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:5838:2: ( (lv_lines_3_0= RULE_STRING ) )*
-                    loop126:
+                    // InternalRoom.g:5899:2: ( (lv_lines_3_0= RULE_STRING ) )*
+                    loop128:
                     do {
-                        int alt126=2;
-                        int LA126_0 = input.LA(1);
+                        int alt128=2;
+                        int LA128_0 = input.LA(1);
 
-                        if ( (LA126_0==RULE_STRING) ) {
-                            alt126=1;
+                        if ( (LA128_0==RULE_STRING) ) {
+                            alt128=1;
                         }
 
 
-                        switch (alt126) {
+                        switch (alt128) {
                     	case 1 :
-                    	    // InternalRoom.g:5839:1: (lv_lines_3_0= RULE_STRING )
+                    	    // InternalRoom.g:5900:1: (lv_lines_3_0= RULE_STRING )
                     	    {
-                    	    // InternalRoom.g:5839:1: (lv_lines_3_0= RULE_STRING )
-                    	    // InternalRoom.g:5840:3: lv_lines_3_0= RULE_STRING
+                    	    // InternalRoom.g:5900:1: (lv_lines_3_0= RULE_STRING )
+                    	    // InternalRoom.g:5901:3: lv_lines_3_0= RULE_STRING
                     	    {
-                    	    lv_lines_3_0=(Token)match(input,RULE_STRING,FOLLOW_116); 
+                    	    lv_lines_3_0=(Token)match(input,RULE_STRING,FOLLOW_117); 
 
                     	    			newLeafNode(lv_lines_3_0, grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_1_1_0()); 
                     	    		
@@ -14579,7 +14753,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop126;
+                    	    break loop128;
                         }
                     } while (true);
 
@@ -14614,7 +14788,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrPoint"
-    // InternalRoom.g:5868:1: entryRuleTrPoint returns [EObject current=null] : iv_ruleTrPoint= ruleTrPoint EOF ;
+    // InternalRoom.g:5929:1: entryRuleTrPoint returns [EObject current=null] : iv_ruleTrPoint= ruleTrPoint EOF ;
     public final EObject entryRuleTrPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14622,8 +14796,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5869:2: (iv_ruleTrPoint= ruleTrPoint EOF )
-            // InternalRoom.g:5870:2: iv_ruleTrPoint= ruleTrPoint EOF
+            // InternalRoom.g:5930:2: (iv_ruleTrPoint= ruleTrPoint EOF )
+            // InternalRoom.g:5931:2: iv_ruleTrPoint= ruleTrPoint EOF
             {
              newCompositeNode(grammarAccess.getTrPointRule()); 
             pushFollow(FOLLOW_1);
@@ -14650,7 +14824,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTrPoint"
-    // InternalRoom.g:5877:1: ruleTrPoint returns [EObject current=null] : (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint ) ;
+    // InternalRoom.g:5938:1: ruleTrPoint returns [EObject current=null] : (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint ) ;
     public final EObject ruleTrPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14664,38 +14838,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5880:28: ( (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint ) )
-            // InternalRoom.g:5881:1: (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint )
+            // InternalRoom.g:5941:28: ( (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint ) )
+            // InternalRoom.g:5942:1: (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint )
             {
-            // InternalRoom.g:5881:1: (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint )
-            int alt128=3;
+            // InternalRoom.g:5942:1: (this_TransitionPoint_0= ruleTransitionPoint | this_EntryPoint_1= ruleEntryPoint | this_ExitPoint_2= ruleExitPoint )
+            int alt130=3;
             switch ( input.LA(1) ) {
             case 87:
             case 88:
                 {
-                alt128=1;
+                alt130=1;
                 }
                 break;
             case 89:
                 {
-                alt128=2;
+                alt130=2;
                 }
                 break;
             case 90:
                 {
-                alt128=3;
+                alt130=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 128, 0, input);
+                    new NoViableAltException("", 130, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt128) {
+            switch (alt130) {
                 case 1 :
-                    // InternalRoom.g:5882:5: this_TransitionPoint_0= ruleTransitionPoint
+                    // InternalRoom.g:5943:5: this_TransitionPoint_0= ruleTransitionPoint
                     {
                      
                             newCompositeNode(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); 
@@ -14713,7 +14887,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:5892:5: this_EntryPoint_1= ruleEntryPoint
+                    // InternalRoom.g:5953:5: this_EntryPoint_1= ruleEntryPoint
                     {
                      
                             newCompositeNode(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); 
@@ -14731,7 +14905,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:5902:5: this_ExitPoint_2= ruleExitPoint
+                    // InternalRoom.g:5963:5: this_ExitPoint_2= ruleExitPoint
                     {
                      
                             newCompositeNode(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); 
@@ -14769,7 +14943,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionPoint"
-    // InternalRoom.g:5918:1: entryRuleTransitionPoint returns [EObject current=null] : iv_ruleTransitionPoint= ruleTransitionPoint EOF ;
+    // InternalRoom.g:5979:1: entryRuleTransitionPoint returns [EObject current=null] : iv_ruleTransitionPoint= ruleTransitionPoint EOF ;
     public final EObject entryRuleTransitionPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14777,8 +14951,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5919:2: (iv_ruleTransitionPoint= ruleTransitionPoint EOF )
-            // InternalRoom.g:5920:2: iv_ruleTransitionPoint= ruleTransitionPoint EOF
+            // InternalRoom.g:5980:2: (iv_ruleTransitionPoint= ruleTransitionPoint EOF )
+            // InternalRoom.g:5981:2: iv_ruleTransitionPoint= ruleTransitionPoint EOF
             {
              newCompositeNode(grammarAccess.getTransitionPointRule()); 
             pushFollow(FOLLOW_1);
@@ -14805,7 +14979,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransitionPoint"
-    // InternalRoom.g:5927:1: ruleTransitionPoint returns [EObject current=null] : ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) ) ;
+    // InternalRoom.g:5988:1: ruleTransitionPoint returns [EObject current=null] : ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) ) ;
     public final EObject ruleTransitionPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14816,27 +14990,27 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5930:28: ( ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) ) )
-            // InternalRoom.g:5931:1: ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) )
+            // InternalRoom.g:5991:28: ( ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) ) )
+            // InternalRoom.g:5992:1: ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) )
             {
-            // InternalRoom.g:5931:1: ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) )
-            // InternalRoom.g:5931:2: ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:5992:1: ( ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) ) )
+            // InternalRoom.g:5992:2: ( (lv_handler_0_0= 'handler' ) )? otherlv_1= 'TransitionPoint' ( (lv_name_2_0= RULE_ID ) )
             {
-            // InternalRoom.g:5931:2: ( (lv_handler_0_0= 'handler' ) )?
-            int alt129=2;
-            int LA129_0 = input.LA(1);
+            // InternalRoom.g:5992:2: ( (lv_handler_0_0= 'handler' ) )?
+            int alt131=2;
+            int LA131_0 = input.LA(1);
 
-            if ( (LA129_0==87) ) {
-                alt129=1;
+            if ( (LA131_0==87) ) {
+                alt131=1;
             }
-            switch (alt129) {
+            switch (alt131) {
                 case 1 :
-                    // InternalRoom.g:5932:1: (lv_handler_0_0= 'handler' )
+                    // InternalRoom.g:5993:1: (lv_handler_0_0= 'handler' )
                     {
-                    // InternalRoom.g:5932:1: (lv_handler_0_0= 'handler' )
-                    // InternalRoom.g:5933:3: lv_handler_0_0= 'handler'
+                    // InternalRoom.g:5993:1: (lv_handler_0_0= 'handler' )
+                    // InternalRoom.g:5994:3: lv_handler_0_0= 'handler'
                     {
-                    lv_handler_0_0=(Token)match(input,87,FOLLOW_117); 
+                    lv_handler_0_0=(Token)match(input,87,FOLLOW_118); 
 
                             newLeafNode(lv_handler_0_0, grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0());
                         
@@ -14859,11 +15033,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1());
                 
-            // InternalRoom.g:5950:1: ( (lv_name_2_0= RULE_ID ) )
-            // InternalRoom.g:5951:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:6011:1: ( (lv_name_2_0= RULE_ID ) )
+            // InternalRoom.g:6012:1: (lv_name_2_0= RULE_ID )
             {
-            // InternalRoom.g:5951:1: (lv_name_2_0= RULE_ID )
-            // InternalRoom.g:5952:3: lv_name_2_0= RULE_ID
+            // InternalRoom.g:6012:1: (lv_name_2_0= RULE_ID )
+            // InternalRoom.g:6013:3: lv_name_2_0= RULE_ID
             {
             lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_2); 
 
@@ -14906,7 +15080,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEntryPoint"
-    // InternalRoom.g:5976:1: entryRuleEntryPoint returns [EObject current=null] : iv_ruleEntryPoint= ruleEntryPoint EOF ;
+    // InternalRoom.g:6037:1: entryRuleEntryPoint returns [EObject current=null] : iv_ruleEntryPoint= ruleEntryPoint EOF ;
     public final EObject entryRuleEntryPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14914,8 +15088,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:5977:2: (iv_ruleEntryPoint= ruleEntryPoint EOF )
-            // InternalRoom.g:5978:2: iv_ruleEntryPoint= ruleEntryPoint EOF
+            // InternalRoom.g:6038:2: (iv_ruleEntryPoint= ruleEntryPoint EOF )
+            // InternalRoom.g:6039:2: iv_ruleEntryPoint= ruleEntryPoint EOF
             {
              newCompositeNode(grammarAccess.getEntryPointRule()); 
             pushFollow(FOLLOW_1);
@@ -14942,7 +15116,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleEntryPoint"
-    // InternalRoom.g:5985:1: ruleEntryPoint returns [EObject current=null] : (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) ) ;
+    // InternalRoom.g:6046:1: ruleEntryPoint returns [EObject current=null] : (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) ) ;
     public final EObject ruleEntryPoint() throws RecognitionException {
         EObject current = null;
 
@@ -14952,21 +15126,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:5988:28: ( (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) ) )
-            // InternalRoom.g:5989:1: (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:6049:28: ( (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) ) )
+            // InternalRoom.g:6050:1: (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) )
             {
-            // InternalRoom.g:5989:1: (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) )
-            // InternalRoom.g:5989:3: otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:6050:1: (otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:6050:3: otherlv_0= 'EntryPoint' ( (lv_name_1_0= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,89,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getEntryPointAccess().getEntryPointKeyword_0());
                 
-            // InternalRoom.g:5993:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:5994:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6054:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:6055:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:5994:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:5995:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:6055:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6056:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_2); 
 
@@ -15009,7 +15183,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleExitPoint"
-    // InternalRoom.g:6019:1: entryRuleExitPoint returns [EObject current=null] : iv_ruleExitPoint= ruleExitPoint EOF ;
+    // InternalRoom.g:6080:1: entryRuleExitPoint returns [EObject current=null] : iv_ruleExitPoint= ruleExitPoint EOF ;
     public final EObject entryRuleExitPoint() throws RecognitionException {
         EObject current = null;
 
@@ -15017,8 +15191,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6020:2: (iv_ruleExitPoint= ruleExitPoint EOF )
-            // InternalRoom.g:6021:2: iv_ruleExitPoint= ruleExitPoint EOF
+            // InternalRoom.g:6081:2: (iv_ruleExitPoint= ruleExitPoint EOF )
+            // InternalRoom.g:6082:2: iv_ruleExitPoint= ruleExitPoint EOF
             {
              newCompositeNode(grammarAccess.getExitPointRule()); 
             pushFollow(FOLLOW_1);
@@ -15045,7 +15219,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleExitPoint"
-    // InternalRoom.g:6028:1: ruleExitPoint returns [EObject current=null] : (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) ) ;
+    // InternalRoom.g:6089:1: ruleExitPoint returns [EObject current=null] : (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) ) ;
     public final EObject ruleExitPoint() throws RecognitionException {
         EObject current = null;
 
@@ -15055,21 +15229,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6031:28: ( (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) ) )
-            // InternalRoom.g:6032:1: (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:6092:28: ( (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) ) )
+            // InternalRoom.g:6093:1: (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) )
             {
-            // InternalRoom.g:6032:1: (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) )
-            // InternalRoom.g:6032:3: otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:6093:1: (otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) ) )
+            // InternalRoom.g:6093:3: otherlv_0= 'ExitPoint' ( (lv_name_1_0= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,90,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getExitPointAccess().getExitPointKeyword_0());
                 
-            // InternalRoom.g:6036:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:6037:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6097:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:6098:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:6037:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:6038:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:6098:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6099:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_2); 
 
@@ -15112,7 +15286,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleChoicePoint"
-    // InternalRoom.g:6062:1: entryRuleChoicePoint returns [EObject current=null] : iv_ruleChoicePoint= ruleChoicePoint EOF ;
+    // InternalRoom.g:6123:1: entryRuleChoicePoint returns [EObject current=null] : iv_ruleChoicePoint= ruleChoicePoint EOF ;
     public final EObject entryRuleChoicePoint() throws RecognitionException {
         EObject current = null;
 
@@ -15120,8 +15294,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6063:2: (iv_ruleChoicePoint= ruleChoicePoint EOF )
-            // InternalRoom.g:6064:2: iv_ruleChoicePoint= ruleChoicePoint EOF
+            // InternalRoom.g:6124:2: (iv_ruleChoicePoint= ruleChoicePoint EOF )
+            // InternalRoom.g:6125:2: iv_ruleChoicePoint= ruleChoicePoint EOF
             {
              newCompositeNode(grammarAccess.getChoicePointRule()); 
             pushFollow(FOLLOW_1);
@@ -15148,7 +15322,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleChoicePoint"
-    // InternalRoom.g:6071:1: ruleChoicePoint returns [EObject current=null] : (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? ) ;
+    // InternalRoom.g:6132:1: ruleChoicePoint returns [EObject current=null] : (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? ) ;
     public final EObject ruleChoicePoint() throws RecognitionException {
         EObject current = null;
 
@@ -15160,21 +15334,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6074:28: ( (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? ) )
-            // InternalRoom.g:6075:1: (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? )
+            // InternalRoom.g:6135:28: ( (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? ) )
+            // InternalRoom.g:6136:1: (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? )
             {
-            // InternalRoom.g:6075:1: (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? )
-            // InternalRoom.g:6075:3: otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )?
+            // InternalRoom.g:6136:1: (otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? )
+            // InternalRoom.g:6136:3: otherlv_0= 'ChoicePoint' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )?
             {
             otherlv_0=(Token)match(input,91,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getChoicePointAccess().getChoicePointKeyword_0());
                 
-            // InternalRoom.g:6079:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:6080:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6140:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:6141:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:6080:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:6081:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:6141:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:6142:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_16); 
 
@@ -15196,19 +15370,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6097:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt130=2;
-            int LA130_0 = input.LA(1);
+            // InternalRoom.g:6158:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt132=2;
+            int LA132_0 = input.LA(1);
 
-            if ( (LA130_0==34) ) {
-                alt130=1;
+            if ( (LA132_0==34) ) {
+                alt132=1;
             }
-            switch (alt130) {
+            switch (alt132) {
                 case 1 :
-                    // InternalRoom.g:6098:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:6159:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6098:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:6099:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:6159:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:6160:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -15258,8 +15432,133 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalRoom.g:6184:1: entryRuleTransitionBase returns [EObject current=null] : iv_ruleTransitionBase= ruleTransitionBase EOF ;
+    public final EObject entryRuleTransitionBase() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleTransitionBase = null;
+
+
+        try {
+            // InternalRoom.g:6185:2: (iv_ruleTransitionBase= ruleTransitionBase EOF )
+            // InternalRoom.g:6186:2: iv_ruleTransitionBase= ruleTransitionBase EOF
+            {
+             newCompositeNode(grammarAccess.getTransitionBaseRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleTransitionBase=ruleTransitionBase();
+
+            state._fsp--;
+
+             current =iv_ruleTransitionBase; 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleTransitionBase"
+
+
+    // $ANTLR start "ruleTransitionBase"
+    // InternalRoom.g:6193:1: ruleTransitionBase returns [EObject current=null] : (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition ) ;
+    public final EObject ruleTransitionBase() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_Transition_0 = null;
+
+        EObject this_RefinedTransition_1 = null;
+
+
+         enterRule(); 
+            
+        try {
+            // InternalRoom.g:6196:28: ( (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition ) )
+            // InternalRoom.g:6197:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            {
+            // InternalRoom.g:6197:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            int alt133=2;
+            int LA133_0 = input.LA(1);
+
+            if ( (LA133_0==92) ) {
+                alt133=1;
+            }
+            else if ( (LA133_0==99) ) {
+                alt133=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 133, 0, input);
+
+                throw nvae;
+            }
+            switch (alt133) {
+                case 1 :
+                    // InternalRoom.g:6198:5: this_Transition_0= ruleTransition
+                    {
+                     
+                            newCompositeNode(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+                        
+                    pushFollow(FOLLOW_2);
+                    this_Transition_0=ruleTransition();
+
+                    state._fsp--;
+
+                     
+                            current = this_Transition_0; 
+                            afterParserOrEnumRuleCall();
+                        
+
+                    }
+                    break;
+                case 2 :
+                    // InternalRoom.g:6208:5: this_RefinedTransition_1= ruleRefinedTransition
+                    {
+                     
+                            newCompositeNode(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+                        
+                    pushFollow(FOLLOW_2);
+                    this_RefinedTransition_1=ruleRefinedTransition();
+
+                    state._fsp--;
+
+                     
+                            current = this_RefinedTransition_1; 
+                            afterParserOrEnumRuleCall();
+                        
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+             leaveRule(); 
+        }
+         
+            catch (RecognitionException re) { 
+                recover(input,re); 
+                appendSkippedTokens();
+            } 
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleTransitionBase"
+
+
     // $ANTLR start "entryRuleTransition"
-    // InternalRoom.g:6125:1: entryRuleTransition returns [EObject current=null] : iv_ruleTransition= ruleTransition EOF ;
+    // InternalRoom.g:6224:1: entryRuleTransition returns [EObject current=null] : iv_ruleTransition= ruleTransition EOF ;
     public final EObject entryRuleTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15267,8 +15566,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6126:2: (iv_ruleTransition= ruleTransition EOF )
-            // InternalRoom.g:6127:2: iv_ruleTransition= ruleTransition EOF
+            // InternalRoom.g:6225:2: (iv_ruleTransition= ruleTransition EOF )
+            // InternalRoom.g:6226:2: iv_ruleTransition= ruleTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15295,7 +15594,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransition"
-    // InternalRoom.g:6134:1: ruleTransition returns [EObject current=null] : (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) ;
+    // InternalRoom.g:6233:1: ruleTransition returns [EObject current=null] : (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) ;
     public final EObject ruleTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15307,74 +15606,74 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6137:28: ( (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) )
-            // InternalRoom.g:6138:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
+            // InternalRoom.g:6236:28: ( (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) )
+            // InternalRoom.g:6237:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
             {
-            // InternalRoom.g:6138:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
-            int alt131=2;
-            int LA131_0 = input.LA(1);
+            // InternalRoom.g:6237:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
+            int alt134=2;
+            int LA134_0 = input.LA(1);
 
-            if ( (LA131_0==92) ) {
-                int LA131_1 = input.LA(2);
+            if ( (LA134_0==92) ) {
+                int LA134_1 = input.LA(2);
 
-                if ( (LA131_1==RULE_ID) ) {
-                    int LA131_2 = input.LA(3);
+                if ( (LA134_1==RULE_ID) ) {
+                    int LA134_2 = input.LA(3);
 
-                    if ( (LA131_2==16) ) {
-                        int LA131_3 = input.LA(4);
+                    if ( (LA134_2==16) ) {
+                        int LA134_3 = input.LA(4);
 
-                        if ( (LA131_3==93) ) {
-                            alt131=1;
+                        if ( (LA134_3==93) ) {
+                            alt134=1;
                         }
-                        else if ( (LA131_3==RULE_ID||(LA131_3>=100 && LA131_3<=101)) ) {
-                            alt131=2;
+                        else if ( (LA134_3==RULE_ID||(LA134_3>=100 && LA134_3<=101)) ) {
+                            alt134=2;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 131, 3, input);
+                                new NoViableAltException("", 134, 3, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 131, 2, input);
+                            new NoViableAltException("", 134, 2, input);
 
                         throw nvae;
                     }
                 }
-                else if ( (LA131_1==16) ) {
-                    int LA131_3 = input.LA(3);
+                else if ( (LA134_1==16) ) {
+                    int LA134_3 = input.LA(3);
 
-                    if ( (LA131_3==93) ) {
-                        alt131=1;
+                    if ( (LA134_3==93) ) {
+                        alt134=1;
                     }
-                    else if ( (LA131_3==RULE_ID||(LA131_3>=100 && LA131_3<=101)) ) {
-                        alt131=2;
+                    else if ( (LA134_3==RULE_ID||(LA134_3>=100 && LA134_3<=101)) ) {
+                        alt134=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 131, 3, input);
+                            new NoViableAltException("", 134, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 131, 1, input);
+                        new NoViableAltException("", 134, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 131, 0, input);
+                    new NoViableAltException("", 134, 0, input);
 
                 throw nvae;
             }
-            switch (alt131) {
+            switch (alt134) {
                 case 1 :
-                    // InternalRoom.g:6139:5: this_InitialTransition_0= ruleInitialTransition
+                    // InternalRoom.g:6238:5: this_InitialTransition_0= ruleInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
@@ -15392,7 +15691,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6149:5: this_NonInitialTransition_1= ruleNonInitialTransition
+                    // InternalRoom.g:6248:5: this_NonInitialTransition_1= ruleNonInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
@@ -15430,7 +15729,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalRoom.g:6165:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
+    // InternalRoom.g:6264:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
     public final EObject entryRuleNonInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15438,8 +15737,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6166:2: (iv_ruleNonInitialTransition= ruleNonInitialTransition EOF )
-            // InternalRoom.g:6167:2: iv_ruleNonInitialTransition= ruleNonInitialTransition EOF
+            // InternalRoom.g:6265:2: (iv_ruleNonInitialTransition= ruleNonInitialTransition EOF )
+            // InternalRoom.g:6266:2: iv_ruleNonInitialTransition= ruleNonInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15466,7 +15765,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleNonInitialTransition"
-    // InternalRoom.g:6174:1: ruleNonInitialTransition returns [EObject current=null] : (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) ;
+    // InternalRoom.g:6273:1: ruleNonInitialTransition returns [EObject current=null] : (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) ;
     public final EObject ruleNonInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15480,15 +15779,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6177:28: ( (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) )
-            // InternalRoom.g:6178:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
+            // InternalRoom.g:6276:28: ( (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) )
+            // InternalRoom.g:6277:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
             {
-            // InternalRoom.g:6178:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
-            int alt132=3;
-            alt132 = dfa132.predict(input);
-            switch (alt132) {
+            // InternalRoom.g:6277:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
+            int alt135=3;
+            alt135 = dfa135.predict(input);
+            switch (alt135) {
                 case 1 :
-                    // InternalRoom.g:6179:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
+                    // InternalRoom.g:6278:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
@@ -15506,7 +15805,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6189:5: this_ContinuationTransition_1= ruleContinuationTransition
+                    // InternalRoom.g:6288:5: this_ContinuationTransition_1= ruleContinuationTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
@@ -15524,7 +15823,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:6199:5: this_CPBranchTransition_2= ruleCPBranchTransition
+                    // InternalRoom.g:6298:5: this_CPBranchTransition_2= ruleCPBranchTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
@@ -15562,7 +15861,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalRoom.g:6215:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
+    // InternalRoom.g:6314:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
     public final EObject entryRuleTransitionChainStartTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15570,8 +15869,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6216:2: (iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF )
-            // InternalRoom.g:6217:2: iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF
+            // InternalRoom.g:6315:2: (iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF )
+            // InternalRoom.g:6316:2: iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15598,7 +15897,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransitionChainStartTransition"
-    // InternalRoom.g:6224:1: ruleTransitionChainStartTransition returns [EObject current=null] : (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) ;
+    // InternalRoom.g:6323:1: ruleTransitionChainStartTransition returns [EObject current=null] : (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) ;
     public final EObject ruleTransitionChainStartTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15610,15 +15909,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6227:28: ( (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) )
-            // InternalRoom.g:6228:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
+            // InternalRoom.g:6326:28: ( (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) )
+            // InternalRoom.g:6327:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
             {
-            // InternalRoom.g:6228:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
-            int alt133=2;
-            alt133 = dfa133.predict(input);
-            switch (alt133) {
+            // InternalRoom.g:6327:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
+            int alt136=2;
+            alt136 = dfa136.predict(input);
+            switch (alt136) {
                 case 1 :
-                    // InternalRoom.g:6229:5: this_TriggeredTransition_0= ruleTriggeredTransition
+                    // InternalRoom.g:6328:5: this_TriggeredTransition_0= ruleTriggeredTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
@@ -15636,7 +15935,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6239:5: this_GuardedTransition_1= ruleGuardedTransition
+                    // InternalRoom.g:6338:5: this_GuardedTransition_1= ruleGuardedTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
@@ -15674,7 +15973,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalRoom.g:6255:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
+    // InternalRoom.g:6354:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
     public final EObject entryRuleInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15682,8 +15981,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6256:2: (iv_ruleInitialTransition= ruleInitialTransition EOF )
-            // InternalRoom.g:6257:2: iv_ruleInitialTransition= ruleInitialTransition EOF
+            // InternalRoom.g:6355:2: (iv_ruleInitialTransition= ruleInitialTransition EOF )
+            // InternalRoom.g:6356:2: iv_ruleInitialTransition= ruleInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15710,7 +16009,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInitialTransition"
-    // InternalRoom.g:6264:1: ruleInitialTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
+    // InternalRoom.g:6363:1: ruleInitialTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
     public final EObject ruleInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15732,29 +16031,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6267:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
-            // InternalRoom.g:6268:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalRoom.g:6366:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
+            // InternalRoom.g:6367:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
             {
-            // InternalRoom.g:6268:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
-            // InternalRoom.g:6268:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            // InternalRoom.g:6367:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalRoom.g:6367:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' otherlv_3= 'initial' otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
             {
-            otherlv_0=(Token)match(input,92,FOLLOW_118); 
+            otherlv_0=(Token)match(input,92,FOLLOW_119); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalRoom.g:6272:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt134=2;
-            int LA134_0 = input.LA(1);
+            // InternalRoom.g:6371:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt137=2;
+            int LA137_0 = input.LA(1);
 
-            if ( (LA134_0==RULE_ID) ) {
-                alt134=1;
+            if ( (LA137_0==RULE_ID) ) {
+                alt137=1;
             }
-            switch (alt134) {
+            switch (alt137) {
                 case 1 :
-                    // InternalRoom.g:6273:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6372:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalRoom.g:6273:1: (lv_name_1_0= RULE_ID )
-                    // InternalRoom.g:6274:3: lv_name_1_0= RULE_ID
+                    // InternalRoom.g:6372:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6373:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -15779,7 +16078,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_2=(Token)match(input,16,FOLLOW_119); 
+            otherlv_2=(Token)match(input,16,FOLLOW_120); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getInitialTransitionAccess().getColonKeyword_2());
                 
@@ -15787,20 +16086,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_3, grammarAccess.getInitialTransitionAccess().getInitialKeyword_3());
                 
-            otherlv_4=(Token)match(input,19,FOLLOW_120); 
+            otherlv_4=(Token)match(input,19,FOLLOW_121); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:6302:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6303:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6401:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6402:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6303:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalRoom.g:6304:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalRoom.g:6402:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6403:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             	    
-            pushFollow(FOLLOW_108);
+            pushFollow(FOLLOW_109);
             lv_to_5_0=ruleTransitionTerminal();
 
             state._fsp--;
@@ -15822,24 +16121,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6320:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt135=2;
-            int LA135_0 = input.LA(1);
+            // InternalRoom.g:6419:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt138=2;
+            int LA138_0 = input.LA(1);
 
-            if ( (LA135_0==34) ) {
-                alt135=1;
+            if ( (LA138_0==34) ) {
+                alt138=1;
             }
-            switch (alt135) {
+            switch (alt138) {
                 case 1 :
-                    // InternalRoom.g:6321:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6420:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6321:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:6322:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:6420:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6421:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
                     	    
-                    pushFollow(FOLLOW_96);
+                    pushFollow(FOLLOW_97);
                     lv_docu_6_0=ruleDocumentation();
 
                     state._fsp--;
@@ -15864,41 +16163,41 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6338:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
-            int alt137=2;
-            int LA137_0 = input.LA(1);
+            // InternalRoom.g:6437:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt140=2;
+            int LA140_0 = input.LA(1);
 
-            if ( (LA137_0==14) ) {
-                alt137=1;
+            if ( (LA140_0==14) ) {
+                alt140=1;
             }
-            switch (alt137) {
+            switch (alt140) {
                 case 1 :
-                    // InternalRoom.g:6338:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalRoom.g:6437:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
-                    otherlv_7=(Token)match(input,14,FOLLOW_121); 
+                    otherlv_7=(Token)match(input,14,FOLLOW_122); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0());
                         
-                    // InternalRoom.g:6342:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
-                    int alt136=2;
-                    int LA136_0 = input.LA(1);
+                    // InternalRoom.g:6441:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt139=2;
+                    int LA139_0 = input.LA(1);
 
-                    if ( (LA136_0==94) ) {
-                        alt136=1;
+                    if ( (LA139_0==94) ) {
+                        alt139=1;
                     }
-                    switch (alt136) {
+                    switch (alt139) {
                         case 1 :
-                            // InternalRoom.g:6342:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6441:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
-                            otherlv_8=(Token)match(input,94,FOLLOW_122); 
+                            otherlv_8=(Token)match(input,94,FOLLOW_123); 
 
                                 	newLeafNode(otherlv_8, grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0());
                                 
-                            // InternalRoom.g:6346:1: ( (lv_action_9_0= ruleDetailCode ) )
-                            // InternalRoom.g:6347:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6445:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6446:1: (lv_action_9_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:6347:1: (lv_action_9_0= ruleDetailCode )
-                            // InternalRoom.g:6348:3: lv_action_9_0= ruleDetailCode
+                            // InternalRoom.g:6446:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6447:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -15962,7 +16261,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalRoom.g:6376:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
+    // InternalRoom.g:6475:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
     public final EObject entryRuleContinuationTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15970,8 +16269,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6377:2: (iv_ruleContinuationTransition= ruleContinuationTransition EOF )
-            // InternalRoom.g:6378:2: iv_ruleContinuationTransition= ruleContinuationTransition EOF
+            // InternalRoom.g:6476:2: (iv_ruleContinuationTransition= ruleContinuationTransition EOF )
+            // InternalRoom.g:6477:2: iv_ruleContinuationTransition= ruleContinuationTransition EOF
             {
              newCompositeNode(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15998,7 +16297,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleContinuationTransition"
-    // InternalRoom.g:6385:1: ruleContinuationTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
+    // InternalRoom.g:6484:1: ruleContinuationTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) ;
     public final EObject ruleContinuationTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16021,29 +16320,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6388:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
-            // InternalRoom.g:6389:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalRoom.g:6487:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? ) )
+            // InternalRoom.g:6488:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
             {
-            // InternalRoom.g:6389:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
-            // InternalRoom.g:6389:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            // InternalRoom.g:6488:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )? )
+            // InternalRoom.g:6488:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
             {
-            otherlv_0=(Token)match(input,92,FOLLOW_118); 
+            otherlv_0=(Token)match(input,92,FOLLOW_119); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalRoom.g:6393:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt138=2;
-            int LA138_0 = input.LA(1);
+            // InternalRoom.g:6492:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt141=2;
+            int LA141_0 = input.LA(1);
 
-            if ( (LA138_0==RULE_ID) ) {
-                alt138=1;
+            if ( (LA141_0==RULE_ID) ) {
+                alt141=1;
             }
-            switch (alt138) {
+            switch (alt141) {
                 case 1 :
-                    // InternalRoom.g:6394:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6493:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalRoom.g:6394:1: (lv_name_1_0= RULE_ID )
-                    // InternalRoom.g:6395:3: lv_name_1_0= RULE_ID
+                    // InternalRoom.g:6493:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6494:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16068,15 +16367,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_2=(Token)match(input,16,FOLLOW_120); 
+            otherlv_2=(Token)match(input,16,FOLLOW_121); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getContinuationTransitionAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:6415:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6416:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6514:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6515:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6416:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalRoom.g:6417:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalRoom.g:6515:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6516:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16103,20 +16402,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_4=(Token)match(input,19,FOLLOW_120); 
+            otherlv_4=(Token)match(input,19,FOLLOW_121); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:6437:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6438:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6536:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6537:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6438:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalRoom.g:6439:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalRoom.g:6537:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6538:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             	    
-            pushFollow(FOLLOW_108);
+            pushFollow(FOLLOW_109);
             lv_to_5_0=ruleTransitionTerminal();
 
             state._fsp--;
@@ -16138,24 +16437,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6455:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt139=2;
-            int LA139_0 = input.LA(1);
+            // InternalRoom.g:6554:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt142=2;
+            int LA142_0 = input.LA(1);
 
-            if ( (LA139_0==34) ) {
-                alt139=1;
+            if ( (LA142_0==34) ) {
+                alt142=1;
             }
-            switch (alt139) {
+            switch (alt142) {
                 case 1 :
-                    // InternalRoom.g:6456:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6555:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6456:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:6457:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:6555:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6556:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
                     	    
-                    pushFollow(FOLLOW_96);
+                    pushFollow(FOLLOW_97);
                     lv_docu_6_0=ruleDocumentation();
 
                     state._fsp--;
@@ -16180,41 +16479,41 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6473:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
-            int alt141=2;
-            int LA141_0 = input.LA(1);
+            // InternalRoom.g:6572:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt144=2;
+            int LA144_0 = input.LA(1);
 
-            if ( (LA141_0==14) ) {
-                alt141=1;
+            if ( (LA144_0==14) ) {
+                alt144=1;
             }
-            switch (alt141) {
+            switch (alt144) {
                 case 1 :
-                    // InternalRoom.g:6473:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalRoom.g:6572:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
-                    otherlv_7=(Token)match(input,14,FOLLOW_121); 
+                    otherlv_7=(Token)match(input,14,FOLLOW_122); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0());
                         
-                    // InternalRoom.g:6477:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
-                    int alt140=2;
-                    int LA140_0 = input.LA(1);
+                    // InternalRoom.g:6576:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt143=2;
+                    int LA143_0 = input.LA(1);
 
-                    if ( (LA140_0==94) ) {
-                        alt140=1;
+                    if ( (LA143_0==94) ) {
+                        alt143=1;
                     }
-                    switch (alt140) {
+                    switch (alt143) {
                         case 1 :
-                            // InternalRoom.g:6477:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6576:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
-                            otherlv_8=(Token)match(input,94,FOLLOW_122); 
+                            otherlv_8=(Token)match(input,94,FOLLOW_123); 
 
                                 	newLeafNode(otherlv_8, grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0());
                                 
-                            // InternalRoom.g:6481:1: ( (lv_action_9_0= ruleDetailCode ) )
-                            // InternalRoom.g:6482:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6580:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6581:1: (lv_action_9_0= ruleDetailCode )
                             {
-                            // InternalRoom.g:6482:1: (lv_action_9_0= ruleDetailCode )
-                            // InternalRoom.g:6483:3: lv_action_9_0= ruleDetailCode
+                            // InternalRoom.g:6581:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6582:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -16278,7 +16577,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalRoom.g:6511:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
+    // InternalRoom.g:6610:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
     public final EObject entryRuleTriggeredTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16286,8 +16585,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6512:2: (iv_ruleTriggeredTransition= ruleTriggeredTransition EOF )
-            // InternalRoom.g:6513:2: iv_ruleTriggeredTransition= ruleTriggeredTransition EOF
+            // InternalRoom.g:6611:2: (iv_ruleTriggeredTransition= ruleTriggeredTransition EOF )
+            // InternalRoom.g:6612:2: iv_ruleTriggeredTransition= ruleTriggeredTransition EOF
             {
              newCompositeNode(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -16314,7 +16613,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTriggeredTransition"
-    // InternalRoom.g:6520:1: ruleTriggeredTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) ;
+    // InternalRoom.g:6619:1: ruleTriggeredTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) ;
     public final EObject ruleTriggeredTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16345,29 +16644,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6523:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) )
-            // InternalRoom.g:6524:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
+            // InternalRoom.g:6622:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' ) )
+            // InternalRoom.g:6623:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
             {
-            // InternalRoom.g:6524:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
-            // InternalRoom.g:6524:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}'
+            // InternalRoom.g:6623:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}' )
+            // InternalRoom.g:6623:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'triggers' otherlv_9= '{' ( (lv_triggers_10_0= ruleTrigger ) ) (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )* otherlv_13= '}' (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )? otherlv_16= '}'
             {
-            otherlv_0=(Token)match(input,92,FOLLOW_118); 
+            otherlv_0=(Token)match(input,92,FOLLOW_119); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalRoom.g:6528:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt142=2;
-            int LA142_0 = input.LA(1);
+            // InternalRoom.g:6627:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt145=2;
+            int LA145_0 = input.LA(1);
 
-            if ( (LA142_0==RULE_ID) ) {
-                alt142=1;
+            if ( (LA145_0==RULE_ID) ) {
+                alt145=1;
             }
-            switch (alt142) {
+            switch (alt145) {
                 case 1 :
-                    // InternalRoom.g:6529:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6628:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalRoom.g:6529:1: (lv_name_1_0= RULE_ID )
-                    // InternalRoom.g:6530:3: lv_name_1_0= RULE_ID
+                    // InternalRoom.g:6628:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6629:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16392,15 +16691,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_2=(Token)match(input,16,FOLLOW_120); 
+            otherlv_2=(Token)match(input,16,FOLLOW_121); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:6550:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6551:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6649:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6650:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6551:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalRoom.g:6552:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalRoom.g:6650:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6651:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16427,15 +16726,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_4=(Token)match(input,19,FOLLOW_120); 
+            otherlv_4=(Token)match(input,19,FOLLOW_121); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:6572:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6573:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6671:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6672:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6573:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalRoom.g:6574:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalRoom.g:6672:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6673:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -16462,19 +16761,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6590:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt143=2;
-            int LA143_0 = input.LA(1);
+            // InternalRoom.g:6689:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt146=2;
+            int LA146_0 = input.LA(1);
 
-            if ( (LA143_0==34) ) {
-                alt143=1;
+            if ( (LA146_0==34) ) {
+                alt146=1;
             }
-            switch (alt143) {
+            switch (alt146) {
                 case 1 :
-                    // InternalRoom.g:6591:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6690:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6591:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:6592:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:6690:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6691:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -16504,7 +16803,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_7=(Token)match(input,14,FOLLOW_123); 
+            otherlv_7=(Token)match(input,14,FOLLOW_124); 
 
                 	newLeafNode(otherlv_7, grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7());
                 
@@ -16512,20 +16811,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_8, grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8());
                 
-            otherlv_9=(Token)match(input,14,FOLLOW_124); 
+            otherlv_9=(Token)match(input,14,FOLLOW_125); 
 
                 	newLeafNode(otherlv_9, grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9());
                 
-            // InternalRoom.g:6620:1: ( (lv_triggers_10_0= ruleTrigger ) )
-            // InternalRoom.g:6621:1: (lv_triggers_10_0= ruleTrigger )
+            // InternalRoom.g:6719:1: ( (lv_triggers_10_0= ruleTrigger ) )
+            // InternalRoom.g:6720:1: (lv_triggers_10_0= ruleTrigger )
             {
-            // InternalRoom.g:6621:1: (lv_triggers_10_0= ruleTrigger )
-            // InternalRoom.g:6622:3: lv_triggers_10_0= ruleTrigger
+            // InternalRoom.g:6720:1: (lv_triggers_10_0= ruleTrigger )
+            // InternalRoom.g:6721:3: lv_triggers_10_0= ruleTrigger
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
             	    
-            pushFollow(FOLLOW_125);
+            pushFollow(FOLLOW_126);
             lv_triggers_10_0=ruleTrigger();
 
             state._fsp--;
@@ -16547,35 +16846,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6638:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
-            loop144:
+            // InternalRoom.g:6737:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
+            loop147:
             do {
-                int alt144=2;
-                int LA144_0 = input.LA(1);
+                int alt147=2;
+                int LA147_0 = input.LA(1);
 
-                if ( (LA144_0==96) ) {
-                    alt144=1;
+                if ( (LA147_0==96) ) {
+                    alt147=1;
                 }
 
 
-                switch (alt144) {
+                switch (alt147) {
             	case 1 :
-            	    // InternalRoom.g:6638:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalRoom.g:6737:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
             	    {
-            	    otherlv_11=(Token)match(input,96,FOLLOW_124); 
+            	    otherlv_11=(Token)match(input,96,FOLLOW_125); 
 
             	        	newLeafNode(otherlv_11, grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0());
             	        
-            	    // InternalRoom.g:6642:1: ( (lv_triggers_12_0= ruleTrigger ) )
-            	    // InternalRoom.g:6643:1: (lv_triggers_12_0= ruleTrigger )
+            	    // InternalRoom.g:6741:1: ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalRoom.g:6742:1: (lv_triggers_12_0= ruleTrigger )
             	    {
-            	    // InternalRoom.g:6643:1: (lv_triggers_12_0= ruleTrigger )
-            	    // InternalRoom.g:6644:3: lv_triggers_12_0= ruleTrigger
+            	    // InternalRoom.g:6742:1: (lv_triggers_12_0= ruleTrigger )
+            	    // InternalRoom.g:6743:3: lv_triggers_12_0= ruleTrigger
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_125);
+            	    pushFollow(FOLLOW_126);
             	    lv_triggers_12_0=ruleTrigger();
 
             	    state._fsp--;
@@ -16602,34 +16901,34 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop144;
+            	    break loop147;
                 }
             } while (true);
 
-            otherlv_13=(Token)match(input,15,FOLLOW_121); 
+            otherlv_13=(Token)match(input,15,FOLLOW_122); 
 
                 	newLeafNode(otherlv_13, grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12());
                 
-            // InternalRoom.g:6664:1: (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )?
-            int alt145=2;
-            int LA145_0 = input.LA(1);
+            // InternalRoom.g:6763:1: (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )?
+            int alt148=2;
+            int LA148_0 = input.LA(1);
 
-            if ( (LA145_0==94) ) {
-                alt145=1;
+            if ( (LA148_0==94) ) {
+                alt148=1;
             }
-            switch (alt145) {
+            switch (alt148) {
                 case 1 :
-                    // InternalRoom.g:6664:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalRoom.g:6763:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
                     {
-                    otherlv_14=(Token)match(input,94,FOLLOW_122); 
+                    otherlv_14=(Token)match(input,94,FOLLOW_123); 
 
                         	newLeafNode(otherlv_14, grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0());
                         
-                    // InternalRoom.g:6668:1: ( (lv_action_15_0= ruleDetailCode ) )
-                    // InternalRoom.g:6669:1: (lv_action_15_0= ruleDetailCode )
+                    // InternalRoom.g:6767:1: ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalRoom.g:6768:1: (lv_action_15_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:6669:1: (lv_action_15_0= ruleDetailCode )
-                    // InternalRoom.g:6670:3: lv_action_15_0= ruleDetailCode
+                    // InternalRoom.g:6768:1: (lv_action_15_0= ruleDetailCode )
+                    // InternalRoom.g:6769:3: lv_action_15_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
@@ -16687,7 +16986,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalRoom.g:6698:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
+    // InternalRoom.g:6797:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
     public final EObject entryRuleGuardedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16695,8 +16994,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6699:2: (iv_ruleGuardedTransition= ruleGuardedTransition EOF )
-            // InternalRoom.g:6700:2: iv_ruleGuardedTransition= ruleGuardedTransition EOF
+            // InternalRoom.g:6798:2: (iv_ruleGuardedTransition= ruleGuardedTransition EOF )
+            // InternalRoom.g:6799:2: iv_ruleGuardedTransition= ruleGuardedTransition EOF
             {
              newCompositeNode(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -16723,7 +17022,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleGuardedTransition"
-    // InternalRoom.g:6707:1: ruleGuardedTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
+    // InternalRoom.g:6806:1: ruleGuardedTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
     public final EObject ruleGuardedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16749,29 +17048,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6710:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
-            // InternalRoom.g:6711:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:6809:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
+            // InternalRoom.g:6810:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
             {
-            // InternalRoom.g:6711:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
-            // InternalRoom.g:6711:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
+            // InternalRoom.g:6810:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:6810:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'guard' ( (lv_guard_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
             {
-            otherlv_0=(Token)match(input,92,FOLLOW_118); 
+            otherlv_0=(Token)match(input,92,FOLLOW_119); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalRoom.g:6715:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt146=2;
-            int LA146_0 = input.LA(1);
+            // InternalRoom.g:6814:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt149=2;
+            int LA149_0 = input.LA(1);
 
-            if ( (LA146_0==RULE_ID) ) {
-                alt146=1;
+            if ( (LA149_0==RULE_ID) ) {
+                alt149=1;
             }
-            switch (alt146) {
+            switch (alt149) {
                 case 1 :
-                    // InternalRoom.g:6716:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6815:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalRoom.g:6716:1: (lv_name_1_0= RULE_ID )
-                    // InternalRoom.g:6717:3: lv_name_1_0= RULE_ID
+                    // InternalRoom.g:6815:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6816:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16796,15 +17095,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_2=(Token)match(input,16,FOLLOW_120); 
+            otherlv_2=(Token)match(input,16,FOLLOW_121); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getGuardedTransitionAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:6737:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6738:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6836:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6837:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6738:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalRoom.g:6739:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalRoom.g:6837:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6838:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16831,15 +17130,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_4=(Token)match(input,19,FOLLOW_120); 
+            otherlv_4=(Token)match(input,19,FOLLOW_121); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:6759:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6760:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6858:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6859:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6760:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalRoom.g:6761:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalRoom.g:6859:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6860:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -16866,19 +17165,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6777:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt147=2;
-            int LA147_0 = input.LA(1);
+            // InternalRoom.g:6876:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt150=2;
+            int LA150_0 = input.LA(1);
 
-            if ( (LA147_0==34) ) {
-                alt147=1;
+            if ( (LA150_0==34) ) {
+                alt150=1;
             }
-            switch (alt147) {
+            switch (alt150) {
                 case 1 :
-                    // InternalRoom.g:6778:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6877:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6778:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:6779:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:6877:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6878:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -16908,24 +17207,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_7=(Token)match(input,14,FOLLOW_126); 
+            otherlv_7=(Token)match(input,14,FOLLOW_127); 
 
                 	newLeafNode(otherlv_7, grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7());
                 
-            otherlv_8=(Token)match(input,97,FOLLOW_127); 
+            otherlv_8=(Token)match(input,97,FOLLOW_128); 
 
                 	newLeafNode(otherlv_8, grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8());
                 
-            // InternalRoom.g:6803:1: ( (lv_guard_9_0= ruleDetailCode ) )
-            // InternalRoom.g:6804:1: (lv_guard_9_0= ruleDetailCode )
+            // InternalRoom.g:6902:1: ( (lv_guard_9_0= ruleDetailCode ) )
+            // InternalRoom.g:6903:1: (lv_guard_9_0= ruleDetailCode )
             {
-            // InternalRoom.g:6804:1: (lv_guard_9_0= ruleDetailCode )
-            // InternalRoom.g:6805:3: lv_guard_9_0= ruleDetailCode
+            // InternalRoom.g:6903:1: (lv_guard_9_0= ruleDetailCode )
+            // InternalRoom.g:6904:3: lv_guard_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
             	    
-            pushFollow(FOLLOW_121);
+            pushFollow(FOLLOW_122);
             lv_guard_9_0=ruleDetailCode();
 
             state._fsp--;
@@ -16947,26 +17246,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6821:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
-            int alt148=2;
-            int LA148_0 = input.LA(1);
+            // InternalRoom.g:6920:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt151=2;
+            int LA151_0 = input.LA(1);
 
-            if ( (LA148_0==94) ) {
-                alt148=1;
+            if ( (LA151_0==94) ) {
+                alt151=1;
             }
-            switch (alt148) {
+            switch (alt151) {
                 case 1 :
-                    // InternalRoom.g:6821:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:6920:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
-                    otherlv_10=(Token)match(input,94,FOLLOW_122); 
+                    otherlv_10=(Token)match(input,94,FOLLOW_123); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0());
                         
-                    // InternalRoom.g:6825:1: ( (lv_action_11_0= ruleDetailCode ) )
-                    // InternalRoom.g:6826:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:6924:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:6925:1: (lv_action_11_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:6826:1: (lv_action_11_0= ruleDetailCode )
-                    // InternalRoom.g:6827:3: lv_action_11_0= ruleDetailCode
+                    // InternalRoom.g:6925:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:6926:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -17024,7 +17323,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalRoom.g:6855:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
+    // InternalRoom.g:6954:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
     public final EObject entryRuleCPBranchTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17032,8 +17331,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:6856:2: (iv_ruleCPBranchTransition= ruleCPBranchTransition EOF )
-            // InternalRoom.g:6857:2: iv_ruleCPBranchTransition= ruleCPBranchTransition EOF
+            // InternalRoom.g:6955:2: (iv_ruleCPBranchTransition= ruleCPBranchTransition EOF )
+            // InternalRoom.g:6956:2: iv_ruleCPBranchTransition= ruleCPBranchTransition EOF
             {
              newCompositeNode(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -17060,7 +17359,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleCPBranchTransition"
-    // InternalRoom.g:6864:1: ruleCPBranchTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
+    // InternalRoom.g:6963:1: ruleCPBranchTransition returns [EObject current=null] : (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) ;
     public final EObject ruleCPBranchTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17086,29 +17385,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:6867:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
-            // InternalRoom.g:6868:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:6966:28: ( (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' ) )
+            // InternalRoom.g:6967:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
             {
-            // InternalRoom.g:6868:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
-            // InternalRoom.g:6868:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
+            // InternalRoom.g:6967:1: (otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}' )
+            // InternalRoom.g:6967:3: otherlv_0= 'Transition' ( (lv_name_1_0= RULE_ID ) )? otherlv_2= ':' ( (lv_from_3_0= ruleTransitionTerminal ) ) otherlv_4= '->' ( (lv_to_5_0= ruleTransitionTerminal ) ) ( (lv_docu_6_0= ruleDocumentation ) )? otherlv_7= '{' otherlv_8= 'cond' ( (lv_condition_9_0= ruleDetailCode ) ) (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )? otherlv_12= '}'
             {
-            otherlv_0=(Token)match(input,92,FOLLOW_118); 
+            otherlv_0=(Token)match(input,92,FOLLOW_119); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0());
                 
-            // InternalRoom.g:6872:1: ( (lv_name_1_0= RULE_ID ) )?
-            int alt149=2;
-            int LA149_0 = input.LA(1);
+            // InternalRoom.g:6971:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt152=2;
+            int LA152_0 = input.LA(1);
 
-            if ( (LA149_0==RULE_ID) ) {
-                alt149=1;
+            if ( (LA152_0==RULE_ID) ) {
+                alt152=1;
             }
-            switch (alt149) {
+            switch (alt152) {
                 case 1 :
-                    // InternalRoom.g:6873:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6972:1: (lv_name_1_0= RULE_ID )
                     {
-                    // InternalRoom.g:6873:1: (lv_name_1_0= RULE_ID )
-                    // InternalRoom.g:6874:3: lv_name_1_0= RULE_ID
+                    // InternalRoom.g:6972:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6973:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -17133,15 +17432,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_2=(Token)match(input,16,FOLLOW_120); 
+            otherlv_2=(Token)match(input,16,FOLLOW_121); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2());
                 
-            // InternalRoom.g:6894:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6895:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6993:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6994:1: (lv_from_3_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6895:1: (lv_from_3_0= ruleTransitionTerminal )
-            // InternalRoom.g:6896:3: lv_from_3_0= ruleTransitionTerminal
+            // InternalRoom.g:6994:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6995:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -17168,15 +17467,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_4=(Token)match(input,19,FOLLOW_120); 
+            otherlv_4=(Token)match(input,19,FOLLOW_121); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4());
                 
-            // InternalRoom.g:6916:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
-            // InternalRoom.g:6917:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:7015:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:7016:1: (lv_to_5_0= ruleTransitionTerminal )
             {
-            // InternalRoom.g:6917:1: (lv_to_5_0= ruleTransitionTerminal )
-            // InternalRoom.g:6918:3: lv_to_5_0= ruleTransitionTerminal
+            // InternalRoom.g:7016:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:7017:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -17203,19 +17502,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6934:2: ( (lv_docu_6_0= ruleDocumentation ) )?
-            int alt150=2;
-            int LA150_0 = input.LA(1);
+            // InternalRoom.g:7033:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt153=2;
+            int LA153_0 = input.LA(1);
 
-            if ( (LA150_0==34) ) {
-                alt150=1;
+            if ( (LA153_0==34) ) {
+                alt153=1;
             }
-            switch (alt150) {
+            switch (alt153) {
                 case 1 :
-                    // InternalRoom.g:6935:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:7034:1: (lv_docu_6_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:6935:1: (lv_docu_6_0= ruleDocumentation )
-                    // InternalRoom.g:6936:3: lv_docu_6_0= ruleDocumentation
+                    // InternalRoom.g:7034:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:7035:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -17245,24 +17544,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_7=(Token)match(input,14,FOLLOW_128); 
+            otherlv_7=(Token)match(input,14,FOLLOW_129); 
 
                 	newLeafNode(otherlv_7, grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7());
                 
-            otherlv_8=(Token)match(input,98,FOLLOW_127); 
+            otherlv_8=(Token)match(input,98,FOLLOW_128); 
 
                 	newLeafNode(otherlv_8, grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8());
                 
-            // InternalRoom.g:6960:1: ( (lv_condition_9_0= ruleDetailCode ) )
-            // InternalRoom.g:6961:1: (lv_condition_9_0= ruleDetailCode )
+            // InternalRoom.g:7059:1: ( (lv_condition_9_0= ruleDetailCode ) )
+            // InternalRoom.g:7060:1: (lv_condition_9_0= ruleDetailCode )
             {
-            // InternalRoom.g:6961:1: (lv_condition_9_0= ruleDetailCode )
-            // InternalRoom.g:6962:3: lv_condition_9_0= ruleDetailCode
+            // InternalRoom.g:7060:1: (lv_condition_9_0= ruleDetailCode )
+            // InternalRoom.g:7061:3: lv_condition_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
             	    
-            pushFollow(FOLLOW_121);
+            pushFollow(FOLLOW_122);
             lv_condition_9_0=ruleDetailCode();
 
             state._fsp--;
@@ -17284,26 +17583,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6978:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
-            int alt151=2;
-            int LA151_0 = input.LA(1);
+            // InternalRoom.g:7077:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt154=2;
+            int LA154_0 = input.LA(1);
 
-            if ( (LA151_0==94) ) {
-                alt151=1;
+            if ( (LA154_0==94) ) {
+                alt154=1;
             }
-            switch (alt151) {
+            switch (alt154) {
                 case 1 :
-                    // InternalRoom.g:6978:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:7077:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
-                    otherlv_10=(Token)match(input,94,FOLLOW_122); 
+                    otherlv_10=(Token)match(input,94,FOLLOW_123); 
 
                         	newLeafNode(otherlv_10, grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0());
                         
-                    // InternalRoom.g:6982:1: ( (lv_action_11_0= ruleDetailCode ) )
-                    // InternalRoom.g:6983:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:7081:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:7082:1: (lv_action_11_0= ruleDetailCode )
                     {
-                    // InternalRoom.g:6983:1: (lv_action_11_0= ruleDetailCode )
-                    // InternalRoom.g:6984:3: lv_action_11_0= ruleDetailCode
+                    // InternalRoom.g:7082:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:7083:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -17361,7 +17660,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalRoom.g:7012:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
+    // InternalRoom.g:7111:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
     public final EObject entryRuleRefinedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17369,8 +17668,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7013:2: (iv_ruleRefinedTransition= ruleRefinedTransition EOF )
-            // InternalRoom.g:7014:2: iv_ruleRefinedTransition= ruleRefinedTransition EOF
+            // InternalRoom.g:7112:2: (iv_ruleRefinedTransition= ruleRefinedTransition EOF )
+            // InternalRoom.g:7113:2: iv_ruleRefinedTransition= ruleRefinedTransition EOF
             {
              newCompositeNode(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -17397,7 +17696,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRefinedTransition"
-    // InternalRoom.g:7021:1: ruleRefinedTransition returns [EObject current=null] : (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) ;
+    // InternalRoom.g:7120:1: ruleRefinedTransition returns [EObject current=null] : (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) ;
     public final EObject ruleRefinedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17413,21 +17712,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7024:28: ( (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) )
-            // InternalRoom.g:7025:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
+            // InternalRoom.g:7123:28: ( (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) )
+            // InternalRoom.g:7124:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
             {
-            // InternalRoom.g:7025:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
-            // InternalRoom.g:7025:3: otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}'
+            // InternalRoom.g:7124:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
+            // InternalRoom.g:7124:3: otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}'
             {
             otherlv_0=(Token)match(input,99,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0());
                 
-            // InternalRoom.g:7029:1: ( ( ruleFQN ) )
-            // InternalRoom.g:7030:1: ( ruleFQN )
+            // InternalRoom.g:7128:1: ( ( ruleFQN ) )
+            // InternalRoom.g:7129:1: ( ruleFQN )
             {
-            // InternalRoom.g:7030:1: ( ruleFQN )
-            // InternalRoom.g:7031:3: ruleFQN
+            // InternalRoom.g:7129:1: ( ruleFQN )
+            // InternalRoom.g:7130:3: ruleFQN
             {
 
             			if (current==null) {
@@ -17451,19 +17750,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7044:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt152=2;
-            int LA152_0 = input.LA(1);
+            // InternalRoom.g:7143:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt155=2;
+            int LA155_0 = input.LA(1);
 
-            if ( (LA152_0==34) ) {
-                alt152=1;
+            if ( (LA155_0==34) ) {
+                alt155=1;
             }
-            switch (alt152) {
+            switch (alt155) {
                 case 1 :
-                    // InternalRoom.g:7045:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:7144:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:7045:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:7046:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:7144:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:7145:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -17493,19 +17792,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,14,FOLLOW_129); 
+            otherlv_3=(Token)match(input,14,FOLLOW_130); 
 
                 	newLeafNode(otherlv_3, grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3());
                 
-            otherlv_4=(Token)match(input,94,FOLLOW_122); 
+            otherlv_4=(Token)match(input,94,FOLLOW_123); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getRefinedTransitionAccess().getActionKeyword_4());
                 
-            // InternalRoom.g:7070:1: ( (lv_action_5_0= ruleDetailCode ) )
-            // InternalRoom.g:7071:1: (lv_action_5_0= ruleDetailCode )
+            // InternalRoom.g:7169:1: ( (lv_action_5_0= ruleDetailCode ) )
+            // InternalRoom.g:7170:1: (lv_action_5_0= ruleDetailCode )
             {
-            // InternalRoom.g:7071:1: (lv_action_5_0= ruleDetailCode )
-            // InternalRoom.g:7072:3: lv_action_5_0= ruleDetailCode
+            // InternalRoom.g:7170:1: (lv_action_5_0= ruleDetailCode )
+            // InternalRoom.g:7171:3: lv_action_5_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
@@ -17557,7 +17856,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalRoom.g:7100:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
+    // InternalRoom.g:7199:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
     public final EObject entryRuleTransitionTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17565,8 +17864,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7101:2: (iv_ruleTransitionTerminal= ruleTransitionTerminal EOF )
-            // InternalRoom.g:7102:2: iv_ruleTransitionTerminal= ruleTransitionTerminal EOF
+            // InternalRoom.g:7200:2: (iv_ruleTransitionTerminal= ruleTransitionTerminal EOF )
+            // InternalRoom.g:7201:2: iv_ruleTransitionTerminal= ruleTransitionTerminal EOF
             {
              newCompositeNode(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17593,7 +17892,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTransitionTerminal"
-    // InternalRoom.g:7109:1: ruleTransitionTerminal returns [EObject current=null] : (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) ;
+    // InternalRoom.g:7208:1: ruleTransitionTerminal returns [EObject current=null] : (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) ;
     public final EObject ruleTransitionTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17609,25 +17908,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7112:28: ( (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) )
-            // InternalRoom.g:7113:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
+            // InternalRoom.g:7211:28: ( (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) )
+            // InternalRoom.g:7212:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
             {
-            // InternalRoom.g:7113:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
-            int alt153=4;
+            // InternalRoom.g:7212:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
+            int alt156=4;
             switch ( input.LA(1) ) {
             case RULE_ID:
                 {
-                int LA153_1 = input.LA(2);
+                int LA156_1 = input.LA(2);
 
-                if ( (LA153_1==24) ) {
-                    alt153=3;
+                if ( (LA156_1==24) ) {
+                    alt156=3;
                 }
-                else if ( (LA153_1==EOF||(LA153_1>=14 && LA153_1<=15)||LA153_1==19||LA153_1==34||LA153_1==81||(LA153_1>=86 && LA153_1<=92)||LA153_1==99) ) {
-                    alt153=1;
+                else if ( (LA156_1==EOF||(LA156_1>=14 && LA156_1<=15)||LA156_1==19||LA156_1==34||LA156_1==81||(LA156_1>=86 && LA156_1<=92)||LA156_1==99) ) {
+                    alt156=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 153, 1, input);
+                        new NoViableAltException("", 156, 1, input);
 
                     throw nvae;
                 }
@@ -17635,24 +17934,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 100:
                 {
-                alt153=2;
+                alt156=2;
                 }
                 break;
             case 101:
                 {
-                alt153=4;
+                alt156=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 153, 0, input);
+                    new NoViableAltException("", 156, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt153) {
+            switch (alt156) {
                 case 1 :
-                    // InternalRoom.g:7114:5: this_StateTerminal_0= ruleStateTerminal
+                    // InternalRoom.g:7213:5: this_StateTerminal_0= ruleStateTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
@@ -17670,7 +17969,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:7124:5: this_TrPointTerminal_1= ruleTrPointTerminal
+                    // InternalRoom.g:7223:5: this_TrPointTerminal_1= ruleTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
@@ -17688,7 +17987,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:7134:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
+                    // InternalRoom.g:7233:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
@@ -17706,7 +18005,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:7144:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
+                    // InternalRoom.g:7243:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
@@ -17744,7 +18043,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalRoom.g:7160:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
+    // InternalRoom.g:7259:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
     public final EObject entryRuleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17752,8 +18051,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7161:2: (iv_ruleStateTerminal= ruleStateTerminal EOF )
-            // InternalRoom.g:7162:2: iv_ruleStateTerminal= ruleStateTerminal EOF
+            // InternalRoom.g:7260:2: (iv_ruleStateTerminal= ruleStateTerminal EOF )
+            // InternalRoom.g:7261:2: iv_ruleStateTerminal= ruleStateTerminal EOF
             {
              newCompositeNode(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17780,7 +18079,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalRoom.g:7169:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
+    // InternalRoom.g:7268:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
     public final EObject ruleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17789,14 +18088,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7172:28: ( ( (otherlv_0= RULE_ID ) ) )
-            // InternalRoom.g:7173:1: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7271:28: ( ( (otherlv_0= RULE_ID ) ) )
+            // InternalRoom.g:7272:1: ( (otherlv_0= RULE_ID ) )
             {
-            // InternalRoom.g:7173:1: ( (otherlv_0= RULE_ID ) )
-            // InternalRoom.g:7174:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7272:1: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7273:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7174:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7175:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7273:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7274:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -17831,7 +18130,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalRoom.g:7194:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
+    // InternalRoom.g:7293:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
     public final EObject entryRuleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17839,8 +18138,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7195:2: (iv_ruleTrPointTerminal= ruleTrPointTerminal EOF )
-            // InternalRoom.g:7196:2: iv_ruleTrPointTerminal= ruleTrPointTerminal EOF
+            // InternalRoom.g:7294:2: (iv_ruleTrPointTerminal= ruleTrPointTerminal EOF )
+            // InternalRoom.g:7295:2: iv_ruleTrPointTerminal= ruleTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17867,7 +18166,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTrPointTerminal"
-    // InternalRoom.g:7203:1: ruleTrPointTerminal returns [EObject current=null] : (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalRoom.g:7302:1: ruleTrPointTerminal returns [EObject current=null] : (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17877,21 +18176,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7206:28: ( (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalRoom.g:7207:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7305:28: ( (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:7306:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalRoom.g:7207:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
-            // InternalRoom.g:7207:3: otherlv_0= 'my' ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7306:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7306:3: otherlv_0= 'my' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,100,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTrPointTerminalAccess().getMyKeyword_0());
                 
-            // InternalRoom.g:7211:1: ( (otherlv_1= RULE_ID ) )
-            // InternalRoom.g:7212:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7310:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7311:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:7212:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:7213:3: otherlv_1= RULE_ID
+            // InternalRoom.g:7311:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7312:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -17929,7 +18228,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalRoom.g:7232:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
+    // InternalRoom.g:7331:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
     public final EObject entryRuleSubStateTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17937,8 +18236,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7233:2: (iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF )
-            // InternalRoom.g:7234:2: iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF
+            // InternalRoom.g:7332:2: (iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF )
+            // InternalRoom.g:7333:2: iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17965,7 +18264,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSubStateTrPointTerminal"
-    // InternalRoom.g:7241:1: ruleSubStateTrPointTerminal returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalRoom.g:7340:1: ruleSubStateTrPointTerminal returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleSubStateTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17976,24 +18275,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7244:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalRoom.g:7245:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7343:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:7344:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalRoom.g:7245:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
-            // InternalRoom.g:7245:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7344:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7344:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) )
             {
-            // InternalRoom.g:7245:2: ( (otherlv_0= RULE_ID ) )
-            // InternalRoom.g:7246:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7344:2: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7345:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7246:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7247:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7345:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7346:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getSubStateTrPointTerminalRule());
             	        }
                     
-            otherlv_0=(Token)match(input,RULE_ID,FOLLOW_86); 
+            otherlv_0=(Token)match(input,RULE_ID,FOLLOW_87); 
 
             		newLeafNode(otherlv_0, grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); 
             	
@@ -18007,11 +18306,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1());
                 
-            // InternalRoom.g:7262:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:7263:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7361:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7362:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7263:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7264:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7362:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7363:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -18049,7 +18348,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalRoom.g:7283:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
+    // InternalRoom.g:7382:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
     public final EObject entryRuleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -18057,8 +18356,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7284:2: (iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF )
-            // InternalRoom.g:7285:2: iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF
+            // InternalRoom.g:7383:2: (iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF )
+            // InternalRoom.g:7384:2: iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF
             {
              newCompositeNode(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -18085,7 +18384,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleChoicepointTerminal"
-    // InternalRoom.g:7292:1: ruleChoicepointTerminal returns [EObject current=null] : (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) ;
+    // InternalRoom.g:7391:1: ruleChoicepointTerminal returns [EObject current=null] : (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -18095,21 +18394,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7295:28: ( (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) )
-            // InternalRoom.g:7296:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7394:28: ( (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:7395:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
             {
-            // InternalRoom.g:7296:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
-            // InternalRoom.g:7296:3: otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7395:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7395:3: otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) )
             {
             otherlv_0=(Token)match(input,101,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0());
                 
-            // InternalRoom.g:7300:1: ( (otherlv_1= RULE_ID ) )
-            // InternalRoom.g:7301:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7399:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7400:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:7301:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:7302:3: otherlv_1= RULE_ID
+            // InternalRoom.g:7400:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7401:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -18147,7 +18446,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalRoom.g:7321:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
+    // InternalRoom.g:7420:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
     public final EObject entryRuleTrigger() throws RecognitionException {
         EObject current = null;
 
@@ -18155,8 +18454,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7322:2: (iv_ruleTrigger= ruleTrigger EOF )
-            // InternalRoom.g:7323:2: iv_ruleTrigger= ruleTrigger EOF
+            // InternalRoom.g:7421:2: (iv_ruleTrigger= ruleTrigger EOF )
+            // InternalRoom.g:7422:2: iv_ruleTrigger= ruleTrigger EOF
             {
              newCompositeNode(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -18183,7 +18482,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleTrigger"
-    // InternalRoom.g:7330:1: ruleTrigger returns [EObject current=null] : (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) ;
+    // InternalRoom.g:7429:1: ruleTrigger returns [EObject current=null] : (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) ;
     public final EObject ruleTrigger() throws RecognitionException {
         EObject current = null;
 
@@ -18200,26 +18499,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7333:28: ( (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) )
-            // InternalRoom.g:7334:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
+            // InternalRoom.g:7432:28: ( (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) )
+            // InternalRoom.g:7433:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
             {
-            // InternalRoom.g:7334:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
-            // InternalRoom.g:7334:3: otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>'
+            // InternalRoom.g:7433:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
+            // InternalRoom.g:7433:3: otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>'
             {
             otherlv_0=(Token)match(input,102,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getTriggerAccess().getLessThanSignKeyword_0());
                 
-            // InternalRoom.g:7338:1: ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) )
-            // InternalRoom.g:7339:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
+            // InternalRoom.g:7437:1: ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) )
+            // InternalRoom.g:7438:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
             {
-            // InternalRoom.g:7339:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
-            // InternalRoom.g:7340:3: lv_msgFromIfPairs_1_0= ruleMessageFromIf
+            // InternalRoom.g:7438:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
+            // InternalRoom.g:7439:3: lv_msgFromIfPairs_1_0= ruleMessageFromIf
             {
              
             	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
             	    
-            pushFollow(FOLLOW_130);
+            pushFollow(FOLLOW_131);
             lv_msgFromIfPairs_1_0=ruleMessageFromIf();
 
             state._fsp--;
@@ -18241,35 +18540,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7356:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
-            loop154:
+            // InternalRoom.g:7455:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
+            loop157:
             do {
-                int alt154=2;
-                int LA154_0 = input.LA(1);
+                int alt157=2;
+                int LA157_0 = input.LA(1);
 
-                if ( (LA154_0==103) ) {
-                    alt154=1;
+                if ( (LA157_0==103) ) {
+                    alt157=1;
                 }
 
 
-                switch (alt154) {
+                switch (alt157) {
             	case 1 :
-            	    // InternalRoom.g:7356:4: otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalRoom.g:7455:4: otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
             	    {
             	    otherlv_2=(Token)match(input,103,FOLLOW_3); 
 
             	        	newLeafNode(otherlv_2, grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0());
             	        
-            	    // InternalRoom.g:7360:1: ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
-            	    // InternalRoom.g:7361:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
+            	    // InternalRoom.g:7459:1: ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalRoom.g:7460:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
             	    {
-            	    // InternalRoom.g:7361:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
-            	    // InternalRoom.g:7362:3: lv_msgFromIfPairs_3_0= ruleMessageFromIf
+            	    // InternalRoom.g:7460:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
+            	    // InternalRoom.g:7461:3: lv_msgFromIfPairs_3_0= ruleMessageFromIf
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
             	    	    
-            	    pushFollow(FOLLOW_130);
+            	    pushFollow(FOLLOW_131);
             	    lv_msgFromIfPairs_3_0=ruleMessageFromIf();
 
             	    state._fsp--;
@@ -18296,28 +18595,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop154;
+            	    break loop157;
                 }
             } while (true);
 
-            // InternalRoom.g:7378:4: ( (lv_guard_4_0= ruleGuard ) )?
-            int alt155=2;
-            int LA155_0 = input.LA(1);
+            // InternalRoom.g:7477:4: ( (lv_guard_4_0= ruleGuard ) )?
+            int alt158=2;
+            int LA158_0 = input.LA(1);
 
-            if ( (LA155_0==97) ) {
-                alt155=1;
+            if ( (LA158_0==97) ) {
+                alt158=1;
             }
-            switch (alt155) {
+            switch (alt158) {
                 case 1 :
-                    // InternalRoom.g:7379:1: (lv_guard_4_0= ruleGuard )
+                    // InternalRoom.g:7478:1: (lv_guard_4_0= ruleGuard )
                     {
-                    // InternalRoom.g:7379:1: (lv_guard_4_0= ruleGuard )
-                    // InternalRoom.g:7380:3: lv_guard_4_0= ruleGuard
+                    // InternalRoom.g:7478:1: (lv_guard_4_0= ruleGuard )
+                    // InternalRoom.g:7479:3: lv_guard_4_0= ruleGuard
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
                     	    
-                    pushFollow(FOLLOW_131);
+                    pushFollow(FOLLOW_132);
                     lv_guard_4_0=ruleGuard();
 
                     state._fsp--;
@@ -18367,7 +18666,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalRoom.g:7408:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
+    // InternalRoom.g:7507:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
     public final EObject entryRuleMessageFromIf() throws RecognitionException {
         EObject current = null;
 
@@ -18375,8 +18674,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7409:2: (iv_ruleMessageFromIf= ruleMessageFromIf EOF )
-            // InternalRoom.g:7410:2: iv_ruleMessageFromIf= ruleMessageFromIf EOF
+            // InternalRoom.g:7508:2: (iv_ruleMessageFromIf= ruleMessageFromIf EOF )
+            // InternalRoom.g:7509:2: iv_ruleMessageFromIf= ruleMessageFromIf EOF
             {
              newCompositeNode(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -18403,7 +18702,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleMessageFromIf"
-    // InternalRoom.g:7417:1: ruleMessageFromIf returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) ;
+    // InternalRoom.g:7516:1: ruleMessageFromIf returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) ;
     public final EObject ruleMessageFromIf() throws RecognitionException {
         EObject current = null;
 
@@ -18414,17 +18713,17 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7420:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) )
-            // InternalRoom.g:7421:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7519:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:7520:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
             {
-            // InternalRoom.g:7421:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
-            // InternalRoom.g:7421:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7520:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7520:2: ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) )
             {
-            // InternalRoom.g:7421:2: ( (otherlv_0= RULE_ID ) )
-            // InternalRoom.g:7422:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7520:2: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7521:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7422:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7423:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7521:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7522:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -18445,11 +18744,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getMessageFromIfAccess().getColonKeyword_1());
                 
-            // InternalRoom.g:7438:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:7439:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7537:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7538:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7439:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7440:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7538:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7539:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -18487,7 +18786,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalRoom.g:7459:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
+    // InternalRoom.g:7558:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
     public final EObject entryRuleGuard() throws RecognitionException {
         EObject current = null;
 
@@ -18495,8 +18794,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7460:2: (iv_ruleGuard= ruleGuard EOF )
-            // InternalRoom.g:7461:2: iv_ruleGuard= ruleGuard EOF
+            // InternalRoom.g:7559:2: (iv_ruleGuard= ruleGuard EOF )
+            // InternalRoom.g:7560:2: iv_ruleGuard= ruleGuard EOF
             {
              newCompositeNode(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -18523,7 +18822,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleGuard"
-    // InternalRoom.g:7468:1: ruleGuard returns [EObject current=null] : (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) ;
+    // InternalRoom.g:7567:1: ruleGuard returns [EObject current=null] : (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) ;
     public final EObject ruleGuard() throws RecognitionException {
         EObject current = null;
 
@@ -18534,21 +18833,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7471:28: ( (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) )
-            // InternalRoom.g:7472:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
+            // InternalRoom.g:7570:28: ( (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:7571:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
             {
-            // InternalRoom.g:7472:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
-            // InternalRoom.g:7472:3: otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) )
+            // InternalRoom.g:7571:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
+            // InternalRoom.g:7571:3: otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) )
             {
             otherlv_0=(Token)match(input,97,FOLLOW_45); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getGuardAccess().getGuardKeyword_0());
                 
-            // InternalRoom.g:7476:1: ( (lv_guard_1_0= ruleDetailCode ) )
-            // InternalRoom.g:7477:1: (lv_guard_1_0= ruleDetailCode )
+            // InternalRoom.g:7575:1: ( (lv_guard_1_0= ruleDetailCode ) )
+            // InternalRoom.g:7576:1: (lv_guard_1_0= ruleDetailCode )
             {
-            // InternalRoom.g:7477:1: (lv_guard_1_0= ruleDetailCode )
-            // InternalRoom.g:7478:3: lv_guard_1_0= ruleDetailCode
+            // InternalRoom.g:7576:1: (lv_guard_1_0= ruleDetailCode )
+            // InternalRoom.g:7577:3: lv_guard_1_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
@@ -18596,7 +18895,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleProtocolSemantics"
-    // InternalRoom.g:7502:1: entryRuleProtocolSemantics returns [EObject current=null] : iv_ruleProtocolSemantics= ruleProtocolSemantics EOF ;
+    // InternalRoom.g:7601:1: entryRuleProtocolSemantics returns [EObject current=null] : iv_ruleProtocolSemantics= ruleProtocolSemantics EOF ;
     public final EObject entryRuleProtocolSemantics() throws RecognitionException {
         EObject current = null;
 
@@ -18604,8 +18903,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7503:2: (iv_ruleProtocolSemantics= ruleProtocolSemantics EOF )
-            // InternalRoom.g:7504:2: iv_ruleProtocolSemantics= ruleProtocolSemantics EOF
+            // InternalRoom.g:7602:2: (iv_ruleProtocolSemantics= ruleProtocolSemantics EOF )
+            // InternalRoom.g:7603:2: iv_ruleProtocolSemantics= ruleProtocolSemantics EOF
             {
              newCompositeNode(grammarAccess.getProtocolSemanticsRule()); 
             pushFollow(FOLLOW_1);
@@ -18632,7 +18931,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleProtocolSemantics"
-    // InternalRoom.g:7511:1: ruleProtocolSemantics returns [EObject current=null] : ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' ) ;
+    // InternalRoom.g:7610:1: ruleProtocolSemantics returns [EObject current=null] : ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' ) ;
     public final EObject ruleProtocolSemantics() throws RecognitionException {
         EObject current = null;
 
@@ -18645,14 +18944,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7514:28: ( ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' ) )
-            // InternalRoom.g:7515:1: ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' )
+            // InternalRoom.g:7613:28: ( ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' ) )
+            // InternalRoom.g:7614:1: ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' )
             {
-            // InternalRoom.g:7515:1: ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' )
-            // InternalRoom.g:7515:2: () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}'
+            // InternalRoom.g:7614:1: ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' )
+            // InternalRoom.g:7614:2: () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}'
             {
-            // InternalRoom.g:7515:2: ()
-            // InternalRoom.g:7516:5: 
+            // InternalRoom.g:7614:2: ()
+            // InternalRoom.g:7615:5: 
             {
 
                     current = forceCreateModelElement(
@@ -18666,32 +18965,32 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getProtocolSemanticsAccess().getSemanticsKeyword_1());
                 
-            otherlv_2=(Token)match(input,14,FOLLOW_132); 
+            otherlv_2=(Token)match(input,14,FOLLOW_133); 
 
                 	newLeafNode(otherlv_2, grammarAccess.getProtocolSemanticsAccess().getLeftCurlyBracketKeyword_2());
                 
-            // InternalRoom.g:7529:1: ( (lv_rules_3_0= ruleSemanticsRule ) )*
-            loop156:
+            // InternalRoom.g:7628:1: ( (lv_rules_3_0= ruleSemanticsRule ) )*
+            loop159:
             do {
-                int alt156=2;
-                int LA156_0 = input.LA(1);
+                int alt159=2;
+                int LA159_0 = input.LA(1);
 
-                if ( ((LA156_0>=106 && LA156_0<=107)) ) {
-                    alt156=1;
+                if ( ((LA159_0>=106 && LA159_0<=107)) ) {
+                    alt159=1;
                 }
 
 
-                switch (alt156) {
+                switch (alt159) {
             	case 1 :
-            	    // InternalRoom.g:7530:1: (lv_rules_3_0= ruleSemanticsRule )
+            	    // InternalRoom.g:7629:1: (lv_rules_3_0= ruleSemanticsRule )
             	    {
-            	    // InternalRoom.g:7530:1: (lv_rules_3_0= ruleSemanticsRule )
-            	    // InternalRoom.g:7531:3: lv_rules_3_0= ruleSemanticsRule
+            	    // InternalRoom.g:7629:1: (lv_rules_3_0= ruleSemanticsRule )
+            	    // InternalRoom.g:7630:3: lv_rules_3_0= ruleSemanticsRule
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); 
             	    	    
-            	    pushFollow(FOLLOW_132);
+            	    pushFollow(FOLLOW_133);
             	    lv_rules_3_0=ruleSemanticsRule();
 
             	    state._fsp--;
@@ -18715,7 +19014,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop156;
+            	    break loop159;
                 }
             } while (true);
 
@@ -18744,7 +19043,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalRoom.g:7559:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
+    // InternalRoom.g:7658:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
     public final EObject entryRuleSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18752,8 +19051,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7560:2: (iv_ruleSemanticsRule= ruleSemanticsRule EOF )
-            // InternalRoom.g:7561:2: iv_ruleSemanticsRule= ruleSemanticsRule EOF
+            // InternalRoom.g:7659:2: (iv_ruleSemanticsRule= ruleSemanticsRule EOF )
+            // InternalRoom.g:7660:2: iv_ruleSemanticsRule= ruleSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -18780,7 +19079,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSemanticsRule"
-    // InternalRoom.g:7568:1: ruleSemanticsRule returns [EObject current=null] : (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) ;
+    // InternalRoom.g:7667:1: ruleSemanticsRule returns [EObject current=null] : (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) ;
     public final EObject ruleSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18792,28 +19091,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7571:28: ( (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) )
-            // InternalRoom.g:7572:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
+            // InternalRoom.g:7670:28: ( (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) )
+            // InternalRoom.g:7671:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
             {
-            // InternalRoom.g:7572:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
-            int alt157=2;
-            int LA157_0 = input.LA(1);
+            // InternalRoom.g:7671:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
+            int alt160=2;
+            int LA160_0 = input.LA(1);
 
-            if ( (LA157_0==106) ) {
-                alt157=1;
+            if ( (LA160_0==106) ) {
+                alt160=1;
             }
-            else if ( (LA157_0==107) ) {
-                alt157=2;
+            else if ( (LA160_0==107) ) {
+                alt160=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 157, 0, input);
+                    new NoViableAltException("", 160, 0, input);
 
                 throw nvae;
             }
-            switch (alt157) {
+            switch (alt160) {
                 case 1 :
-                    // InternalRoom.g:7573:5: this_InSemanticsRule_0= ruleInSemanticsRule
+                    // InternalRoom.g:7672:5: this_InSemanticsRule_0= ruleInSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
@@ -18831,7 +19130,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:7583:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
+                    // InternalRoom.g:7682:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
@@ -18869,7 +19168,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalRoom.g:7599:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
+    // InternalRoom.g:7698:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
     public final EObject entryRuleInSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18877,8 +19176,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7600:2: (iv_ruleInSemanticsRule= ruleInSemanticsRule EOF )
-            // InternalRoom.g:7601:2: iv_ruleInSemanticsRule= ruleInSemanticsRule EOF
+            // InternalRoom.g:7699:2: (iv_ruleInSemanticsRule= ruleInSemanticsRule EOF )
+            // InternalRoom.g:7700:2: iv_ruleInSemanticsRule= ruleInSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -18905,7 +19204,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInSemanticsRule"
-    // InternalRoom.g:7608:1: ruleInSemanticsRule returns [EObject current=null] : (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
+    // InternalRoom.g:7707:1: ruleInSemanticsRule returns [EObject current=null] : (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
     public final EObject ruleInSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18926,11 +19225,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7611:28: ( (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
-            // InternalRoom.g:7612:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalRoom.g:7710:28: ( (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
+            // InternalRoom.g:7711:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
             {
-            // InternalRoom.g:7612:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
-            // InternalRoom.g:7612:3: otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            // InternalRoom.g:7711:1: (otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalRoom.g:7711:3: otherlv_0= 'in' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
             {
             otherlv_0=(Token)match(input,106,FOLLOW_8); 
 
@@ -18940,18 +19239,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1());
                 
-            // InternalRoom.g:7620:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:7621:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7719:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7720:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7621:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7622:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7720:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7721:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getInSemanticsRuleRule());
             	        }
                     
-            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_133); 
+            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_134); 
 
             		newLeafNode(otherlv_2, grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
             	
@@ -18961,46 +19260,46 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7633:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
-            int alt160=2;
-            int LA160_0 = input.LA(1);
+            // InternalRoom.g:7732:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            int alt163=2;
+            int LA163_0 = input.LA(1);
 
-            if ( (LA160_0==19) ) {
-                alt160=1;
+            if ( (LA163_0==19) ) {
+                alt163=1;
             }
-            switch (alt160) {
+            switch (alt163) {
                 case 1 :
-                    // InternalRoom.g:7633:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    // InternalRoom.g:7732:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
                     {
-                    otherlv_3=(Token)match(input,19,FOLLOW_134); 
+                    otherlv_3=(Token)match(input,19,FOLLOW_135); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0());
                         
-                    // InternalRoom.g:7637:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
-                    int alt159=2;
-                    int LA159_0 = input.LA(1);
+                    // InternalRoom.g:7736:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    int alt162=2;
+                    int LA162_0 = input.LA(1);
 
-                    if ( ((LA159_0>=106 && LA159_0<=107)) ) {
-                        alt159=1;
+                    if ( ((LA162_0>=106 && LA162_0<=107)) ) {
+                        alt162=1;
                     }
-                    else if ( (LA159_0==20) ) {
-                        alt159=2;
+                    else if ( (LA162_0==20) ) {
+                        alt162=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 159, 0, input);
+                            new NoViableAltException("", 162, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt159) {
+                    switch (alt162) {
                         case 1 :
-                            // InternalRoom.g:7637:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7736:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
                             {
-                            // InternalRoom.g:7637:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
-                            // InternalRoom.g:7638:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7736:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7737:1: (lv_followUps_4_0= ruleSemanticsRule )
                             {
-                            // InternalRoom.g:7638:1: (lv_followUps_4_0= ruleSemanticsRule )
-                            // InternalRoom.g:7639:3: lv_followUps_4_0= ruleSemanticsRule
+                            // InternalRoom.g:7737:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7738:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -19031,25 +19330,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:7656:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7755:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
                             {
-                            // InternalRoom.g:7656:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
-                            // InternalRoom.g:7656:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
+                            // InternalRoom.g:7755:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7755:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
                             {
-                            otherlv_5=(Token)match(input,20,FOLLOW_135); 
+                            otherlv_5=(Token)match(input,20,FOLLOW_136); 
 
                                 	newLeafNode(otherlv_5, grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0());
                                 
-                            // InternalRoom.g:7660:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
-                            // InternalRoom.g:7661:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7759:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7760:1: (lv_followUps_6_0= ruleSemanticsRule )
                             {
-                            // InternalRoom.g:7661:1: (lv_followUps_6_0= ruleSemanticsRule )
-                            // InternalRoom.g:7662:3: lv_followUps_6_0= ruleSemanticsRule
+                            // InternalRoom.g:7760:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7761:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
                             	    
-                            pushFollow(FOLLOW_136);
+                            pushFollow(FOLLOW_137);
                             lv_followUps_6_0=ruleSemanticsRule();
 
                             state._fsp--;
@@ -19071,31 +19370,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalRoom.g:7678:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt158=0;
-                            loop158:
+                            // InternalRoom.g:7777:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt161=0;
+                            loop161:
                             do {
-                                int alt158=2;
-                                int LA158_0 = input.LA(1);
+                                int alt161=2;
+                                int LA161_0 = input.LA(1);
 
-                                if ( (LA158_0==25) ) {
-                                    alt158=1;
+                                if ( (LA161_0==25) ) {
+                                    alt161=1;
                                 }
 
 
-                                switch (alt158) {
+                                switch (alt161) {
                             	case 1 :
-                            	    // InternalRoom.g:7678:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7777:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
-                            	    otherlv_7=(Token)match(input,25,FOLLOW_135); 
+                            	    otherlv_7=(Token)match(input,25,FOLLOW_136); 
 
                             	        	newLeafNode(otherlv_7, grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0());
                             	        
-                            	    // InternalRoom.g:7682:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
-                            	    // InternalRoom.g:7683:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7781:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7782:1: (lv_followUps_8_0= ruleSemanticsRule )
                             	    {
-                            	    // InternalRoom.g:7683:1: (lv_followUps_8_0= ruleSemanticsRule )
-                            	    // InternalRoom.g:7684:3: lv_followUps_8_0= ruleSemanticsRule
+                            	    // InternalRoom.g:7782:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7783:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -19127,12 +19426,12 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt158 >= 1 ) break loop158;
+                            	    if ( cnt161 >= 1 ) break loop161;
                                         EarlyExitException eee =
-                                            new EarlyExitException(158, input);
+                                            new EarlyExitException(161, input);
                                         throw eee;
                                 }
-                                cnt158++;
+                                cnt161++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,21,FOLLOW_2); 
@@ -19175,7 +19474,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalRoom.g:7712:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
+    // InternalRoom.g:7811:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
     public final EObject entryRuleOutSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -19183,8 +19482,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7713:2: (iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF )
-            // InternalRoom.g:7714:2: iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF
+            // InternalRoom.g:7812:2: (iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF )
+            // InternalRoom.g:7813:2: iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -19211,7 +19510,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleOutSemanticsRule"
-    // InternalRoom.g:7721:1: ruleOutSemanticsRule returns [EObject current=null] : (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
+    // InternalRoom.g:7820:1: ruleOutSemanticsRule returns [EObject current=null] : (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) ;
     public final EObject ruleOutSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -19232,11 +19531,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7724:28: ( (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
-            // InternalRoom.g:7725:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalRoom.g:7823:28: ( (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? ) )
+            // InternalRoom.g:7824:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
             {
-            // InternalRoom.g:7725:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
-            // InternalRoom.g:7725:3: otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            // InternalRoom.g:7824:1: (otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )? )
+            // InternalRoom.g:7824:3: otherlv_0= 'out' otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
             {
             otherlv_0=(Token)match(input,107,FOLLOW_8); 
 
@@ -19246,18 +19545,18 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1());
                 
-            // InternalRoom.g:7733:1: ( (otherlv_2= RULE_ID ) )
-            // InternalRoom.g:7734:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7832:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7833:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7734:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7735:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7833:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7834:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
             	            current = createModelElement(grammarAccess.getOutSemanticsRuleRule());
             	        }
                     
-            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_133); 
+            otherlv_2=(Token)match(input,RULE_ID,FOLLOW_134); 
 
             		newLeafNode(otherlv_2, grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
             	
@@ -19267,46 +19566,46 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7746:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
-            int alt163=2;
-            int LA163_0 = input.LA(1);
+            // InternalRoom.g:7845:2: (otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) ) )?
+            int alt166=2;
+            int LA166_0 = input.LA(1);
 
-            if ( (LA163_0==19) ) {
-                alt163=1;
+            if ( (LA166_0==19) ) {
+                alt166=1;
             }
-            switch (alt163) {
+            switch (alt166) {
                 case 1 :
-                    // InternalRoom.g:7746:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    // InternalRoom.g:7845:4: otherlv_3= '->' ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
                     {
-                    otherlv_3=(Token)match(input,19,FOLLOW_134); 
+                    otherlv_3=(Token)match(input,19,FOLLOW_135); 
 
                         	newLeafNode(otherlv_3, grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0());
                         
-                    // InternalRoom.g:7750:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
-                    int alt162=2;
-                    int LA162_0 = input.LA(1);
+                    // InternalRoom.g:7849:1: ( ( (lv_followUps_4_0= ruleSemanticsRule ) ) | (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' ) )
+                    int alt165=2;
+                    int LA165_0 = input.LA(1);
 
-                    if ( ((LA162_0>=106 && LA162_0<=107)) ) {
-                        alt162=1;
+                    if ( ((LA165_0>=106 && LA165_0<=107)) ) {
+                        alt165=1;
                     }
-                    else if ( (LA162_0==20) ) {
-                        alt162=2;
+                    else if ( (LA165_0==20) ) {
+                        alt165=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 162, 0, input);
+                            new NoViableAltException("", 165, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt162) {
+                    switch (alt165) {
                         case 1 :
-                            // InternalRoom.g:7750:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7849:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
                             {
-                            // InternalRoom.g:7750:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
-                            // InternalRoom.g:7751:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7849:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7850:1: (lv_followUps_4_0= ruleSemanticsRule )
                             {
-                            // InternalRoom.g:7751:1: (lv_followUps_4_0= ruleSemanticsRule )
-                            // InternalRoom.g:7752:3: lv_followUps_4_0= ruleSemanticsRule
+                            // InternalRoom.g:7850:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7851:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -19337,25 +19636,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:7769:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7868:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
                             {
-                            // InternalRoom.g:7769:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
-                            // InternalRoom.g:7769:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
+                            // InternalRoom.g:7868:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7868:8: otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')'
                             {
-                            otherlv_5=(Token)match(input,20,FOLLOW_135); 
+                            otherlv_5=(Token)match(input,20,FOLLOW_136); 
 
                                 	newLeafNode(otherlv_5, grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0());
                                 
-                            // InternalRoom.g:7773:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
-                            // InternalRoom.g:7774:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7872:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7873:1: (lv_followUps_6_0= ruleSemanticsRule )
                             {
-                            // InternalRoom.g:7774:1: (lv_followUps_6_0= ruleSemanticsRule )
-                            // InternalRoom.g:7775:3: lv_followUps_6_0= ruleSemanticsRule
+                            // InternalRoom.g:7873:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7874:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
                             	    
-                            pushFollow(FOLLOW_136);
+                            pushFollow(FOLLOW_137);
                             lv_followUps_6_0=ruleSemanticsRule();
 
                             state._fsp--;
@@ -19377,31 +19676,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalRoom.g:7791:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt161=0;
-                            loop161:
+                            // InternalRoom.g:7890:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt164=0;
+                            loop164:
                             do {
-                                int alt161=2;
-                                int LA161_0 = input.LA(1);
+                                int alt164=2;
+                                int LA164_0 = input.LA(1);
 
-                                if ( (LA161_0==25) ) {
-                                    alt161=1;
+                                if ( (LA164_0==25) ) {
+                                    alt164=1;
                                 }
 
 
-                                switch (alt161) {
+                                switch (alt164) {
                             	case 1 :
-                            	    // InternalRoom.g:7791:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7890:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
-                            	    otherlv_7=(Token)match(input,25,FOLLOW_135); 
+                            	    otherlv_7=(Token)match(input,25,FOLLOW_136); 
 
                             	        	newLeafNode(otherlv_7, grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0());
                             	        
-                            	    // InternalRoom.g:7795:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
-                            	    // InternalRoom.g:7796:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7894:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7895:1: (lv_followUps_8_0= ruleSemanticsRule )
                             	    {
-                            	    // InternalRoom.g:7796:1: (lv_followUps_8_0= ruleSemanticsRule )
-                            	    // InternalRoom.g:7797:3: lv_followUps_8_0= ruleSemanticsRule
+                            	    // InternalRoom.g:7895:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7896:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -19433,12 +19732,12 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt161 >= 1 ) break loop161;
+                            	    if ( cnt164 >= 1 ) break loop164;
                                         EarlyExitException eee =
-                                            new EarlyExitException(161, input);
+                                            new EarlyExitException(164, input);
                                         throw eee;
                                 }
-                                cnt161++;
+                                cnt164++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,21,FOLLOW_2); 
@@ -19481,7 +19780,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotation"
-    // InternalRoom.g:7825:1: entryRuleAnnotation returns [EObject current=null] : iv_ruleAnnotation= ruleAnnotation EOF ;
+    // InternalRoom.g:7924:1: entryRuleAnnotation returns [EObject current=null] : iv_ruleAnnotation= ruleAnnotation EOF ;
     public final EObject entryRuleAnnotation() throws RecognitionException {
         EObject current = null;
 
@@ -19489,8 +19788,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7826:2: (iv_ruleAnnotation= ruleAnnotation EOF )
-            // InternalRoom.g:7827:2: iv_ruleAnnotation= ruleAnnotation EOF
+            // InternalRoom.g:7925:2: (iv_ruleAnnotation= ruleAnnotation EOF )
+            // InternalRoom.g:7926:2: iv_ruleAnnotation= ruleAnnotation EOF
             {
              newCompositeNode(grammarAccess.getAnnotationRule()); 
             pushFollow(FOLLOW_1);
@@ -19517,7 +19816,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotation"
-    // InternalRoom.g:7834:1: ruleAnnotation returns [EObject current=null] : (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? ) ;
+    // InternalRoom.g:7933:1: ruleAnnotation returns [EObject current=null] : (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? ) ;
     public final EObject ruleAnnotation() throws RecognitionException {
         EObject current = null;
 
@@ -19533,21 +19832,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7837:28: ( (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? ) )
-            // InternalRoom.g:7838:1: (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? )
+            // InternalRoom.g:7936:28: ( (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? ) )
+            // InternalRoom.g:7937:1: (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? )
             {
-            // InternalRoom.g:7838:1: (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? )
-            // InternalRoom.g:7838:3: otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )?
+            // InternalRoom.g:7937:1: (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? )
+            // InternalRoom.g:7937:3: otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )?
             {
             otherlv_0=(Token)match(input,108,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getAnnotationAccess().getCommercialAtKeyword_0());
                 
-            // InternalRoom.g:7842:1: ( ( ruleFQN ) )
-            // InternalRoom.g:7843:1: ( ruleFQN )
+            // InternalRoom.g:7941:1: ( ( ruleFQN ) )
+            // InternalRoom.g:7942:1: ( ruleFQN )
             {
-            // InternalRoom.g:7843:1: ( ruleFQN )
-            // InternalRoom.g:7844:3: ruleFQN
+            // InternalRoom.g:7942:1: ( ruleFQN )
+            // InternalRoom.g:7943:3: ruleFQN
             {
 
             			if (current==null) {
@@ -19557,7 +19856,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
             	        newCompositeNode(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeCrossReference_1_0()); 
             	    
-            pushFollow(FOLLOW_137);
+            pushFollow(FOLLOW_138);
             ruleFQN();
 
             state._fsp--;
@@ -19571,26 +19870,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7857:2: (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )?
-            int alt165=2;
-            int LA165_0 = input.LA(1);
+            // InternalRoom.g:7956:2: (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )?
+            int alt168=2;
+            int LA168_0 = input.LA(1);
 
-            if ( (LA165_0==20) ) {
-                alt165=1;
+            if ( (LA168_0==20) ) {
+                alt168=1;
             }
-            switch (alt165) {
+            switch (alt168) {
                 case 1 :
-                    // InternalRoom.g:7857:4: otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')'
+                    // InternalRoom.g:7956:4: otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')'
                     {
                     otherlv_2=(Token)match(input,20,FOLLOW_3); 
 
                         	newLeafNode(otherlv_2, grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_2_0());
                         
-                    // InternalRoom.g:7861:1: ( (lv_attributes_3_0= ruleKeyValue ) )
-                    // InternalRoom.g:7862:1: (lv_attributes_3_0= ruleKeyValue )
+                    // InternalRoom.g:7960:1: ( (lv_attributes_3_0= ruleKeyValue ) )
+                    // InternalRoom.g:7961:1: (lv_attributes_3_0= ruleKeyValue )
                     {
-                    // InternalRoom.g:7862:1: (lv_attributes_3_0= ruleKeyValue )
-                    // InternalRoom.g:7863:3: lv_attributes_3_0= ruleKeyValue
+                    // InternalRoom.g:7961:1: (lv_attributes_3_0= ruleKeyValue )
+                    // InternalRoom.g:7962:3: lv_attributes_3_0= ruleKeyValue
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); 
@@ -19617,30 +19916,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:7879:2: (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )*
-                    loop164:
+                    // InternalRoom.g:7978:2: (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )*
+                    loop167:
                     do {
-                        int alt164=2;
-                        int LA164_0 = input.LA(1);
+                        int alt167=2;
+                        int LA167_0 = input.LA(1);
 
-                        if ( (LA164_0==25) ) {
-                            alt164=1;
+                        if ( (LA167_0==25) ) {
+                            alt167=1;
                         }
 
 
-                        switch (alt164) {
+                        switch (alt167) {
                     	case 1 :
-                    	    // InternalRoom.g:7879:4: otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) )
+                    	    // InternalRoom.g:7978:4: otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) )
                     	    {
                     	    otherlv_4=(Token)match(input,25,FOLLOW_3); 
 
                     	        	newLeafNode(otherlv_4, grammarAccess.getAnnotationAccess().getCommaKeyword_2_2_0());
                     	        
-                    	    // InternalRoom.g:7883:1: ( (lv_attributes_5_0= ruleKeyValue ) )
-                    	    // InternalRoom.g:7884:1: (lv_attributes_5_0= ruleKeyValue )
+                    	    // InternalRoom.g:7982:1: ( (lv_attributes_5_0= ruleKeyValue ) )
+                    	    // InternalRoom.g:7983:1: (lv_attributes_5_0= ruleKeyValue )
                     	    {
-                    	    // InternalRoom.g:7884:1: (lv_attributes_5_0= ruleKeyValue )
-                    	    // InternalRoom.g:7885:3: lv_attributes_5_0= ruleKeyValue
+                    	    // InternalRoom.g:7983:1: (lv_attributes_5_0= ruleKeyValue )
+                    	    // InternalRoom.g:7984:3: lv_attributes_5_0= ruleKeyValue
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); 
@@ -19672,7 +19971,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop164;
+                    	    break loop167;
                         }
                     } while (true);
 
@@ -19707,7 +20006,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalRoom.g:7913:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
+    // InternalRoom.g:8012:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
     public final EObject entryRuleKeyValue() throws RecognitionException {
         EObject current = null;
 
@@ -19715,8 +20014,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7914:2: (iv_ruleKeyValue= ruleKeyValue EOF )
-            // InternalRoom.g:7915:2: iv_ruleKeyValue= ruleKeyValue EOF
+            // InternalRoom.g:8013:2: (iv_ruleKeyValue= ruleKeyValue EOF )
+            // InternalRoom.g:8014:2: iv_ruleKeyValue= ruleKeyValue EOF
             {
              newCompositeNode(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -19743,7 +20042,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleKeyValue"
-    // InternalRoom.g:7922:1: ruleKeyValue returns [EObject current=null] : ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) ;
+    // InternalRoom.g:8021:1: ruleKeyValue returns [EObject current=null] : ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) ;
     public final EObject ruleKeyValue() throws RecognitionException {
         EObject current = null;
 
@@ -19755,19 +20054,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7925:28: ( ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) )
-            // InternalRoom.g:7926:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
+            // InternalRoom.g:8024:28: ( ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) )
+            // InternalRoom.g:8025:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
             {
-            // InternalRoom.g:7926:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
-            // InternalRoom.g:7926:2: ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) )
+            // InternalRoom.g:8025:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
+            // InternalRoom.g:8025:2: ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) )
             {
-            // InternalRoom.g:7926:2: ( (lv_key_0_0= RULE_ID ) )
-            // InternalRoom.g:7927:1: (lv_key_0_0= RULE_ID )
+            // InternalRoom.g:8025:2: ( (lv_key_0_0= RULE_ID ) )
+            // InternalRoom.g:8026:1: (lv_key_0_0= RULE_ID )
             {
-            // InternalRoom.g:7927:1: (lv_key_0_0= RULE_ID )
-            // InternalRoom.g:7928:3: lv_key_0_0= RULE_ID
+            // InternalRoom.g:8026:1: (lv_key_0_0= RULE_ID )
+            // InternalRoom.g:8027:3: lv_key_0_0= RULE_ID
             {
-            lv_key_0_0=(Token)match(input,RULE_ID,FOLLOW_138); 
+            lv_key_0_0=(Token)match(input,RULE_ID,FOLLOW_139); 
 
             			newLeafNode(lv_key_0_0, grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); 
             		
@@ -19787,15 +20086,15 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_1=(Token)match(input,26,FOLLOW_139); 
+            otherlv_1=(Token)match(input,26,FOLLOW_140); 
 
                 	newLeafNode(otherlv_1, grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1());
                 
-            // InternalRoom.g:7948:1: ( (lv_value_2_0= ruleLiteral ) )
-            // InternalRoom.g:7949:1: (lv_value_2_0= ruleLiteral )
+            // InternalRoom.g:8047:1: ( (lv_value_2_0= ruleLiteral ) )
+            // InternalRoom.g:8048:1: (lv_value_2_0= ruleLiteral )
             {
-            // InternalRoom.g:7949:1: (lv_value_2_0= ruleLiteral )
-            // InternalRoom.g:7950:3: lv_value_2_0= ruleLiteral
+            // InternalRoom.g:8048:1: (lv_value_2_0= ruleLiteral )
+            // InternalRoom.g:8049:3: lv_value_2_0= ruleLiteral
             {
              
             	        newCompositeNode(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
@@ -19843,7 +20142,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationType"
-    // InternalRoom.g:7974:1: entryRuleAnnotationType returns [EObject current=null] : iv_ruleAnnotationType= ruleAnnotationType EOF ;
+    // InternalRoom.g:8073:1: entryRuleAnnotationType returns [EObject current=null] : iv_ruleAnnotationType= ruleAnnotationType EOF ;
     public final EObject entryRuleAnnotationType() throws RecognitionException {
         EObject current = null;
 
@@ -19851,8 +20150,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:7975:2: (iv_ruleAnnotationType= ruleAnnotationType EOF )
-            // InternalRoom.g:7976:2: iv_ruleAnnotationType= ruleAnnotationType EOF
+            // InternalRoom.g:8074:2: (iv_ruleAnnotationType= ruleAnnotationType EOF )
+            // InternalRoom.g:8075:2: iv_ruleAnnotationType= ruleAnnotationType EOF
             {
              newCompositeNode(grammarAccess.getAnnotationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -19879,7 +20178,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotationType"
-    // InternalRoom.g:7983:1: ruleAnnotationType returns [EObject current=null] : (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' ) ;
+    // InternalRoom.g:8082:1: ruleAnnotationType returns [EObject current=null] : (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' ) ;
     public final EObject ruleAnnotationType() throws RecognitionException {
         EObject current = null;
 
@@ -19906,21 +20205,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:7986:28: ( (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' ) )
-            // InternalRoom.g:7987:1: (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' )
+            // InternalRoom.g:8085:28: ( (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' ) )
+            // InternalRoom.g:8086:1: (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' )
             {
-            // InternalRoom.g:7987:1: (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' )
-            // InternalRoom.g:7987:3: otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}'
+            // InternalRoom.g:8086:1: (otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}' )
+            // InternalRoom.g:8086:3: otherlv_0= 'AnnotationType' ( (lv_name_1_0= RULE_ID ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'target' otherlv_5= '=' ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) ) ( (lv_attributes_12_0= ruleAnnotationAttribute ) )* otherlv_13= '}'
             {
             otherlv_0=(Token)match(input,109,FOLLOW_3); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getAnnotationTypeAccess().getAnnotationTypeKeyword_0());
                 
-            // InternalRoom.g:7991:1: ( (lv_name_1_0= RULE_ID ) )
-            // InternalRoom.g:7992:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:8090:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:8091:1: (lv_name_1_0= RULE_ID )
             {
-            // InternalRoom.g:7992:1: (lv_name_1_0= RULE_ID )
-            // InternalRoom.g:7993:3: lv_name_1_0= RULE_ID
+            // InternalRoom.g:8091:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:8092:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_4); 
 
@@ -19942,19 +20241,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8009:2: ( (lv_docu_2_0= ruleDocumentation ) )?
-            int alt166=2;
-            int LA166_0 = input.LA(1);
+            // InternalRoom.g:8108:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt169=2;
+            int LA169_0 = input.LA(1);
 
-            if ( (LA166_0==34) ) {
-                alt166=1;
+            if ( (LA169_0==34) ) {
+                alt169=1;
             }
-            switch (alt166) {
+            switch (alt169) {
                 case 1 :
-                    // InternalRoom.g:8010:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:8109:1: (lv_docu_2_0= ruleDocumentation )
                     {
-                    // InternalRoom.g:8010:1: (lv_docu_2_0= ruleDocumentation )
-                    // InternalRoom.g:8011:3: lv_docu_2_0= ruleDocumentation
+                    // InternalRoom.g:8109:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:8110:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -19984,48 +20283,48 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_3=(Token)match(input,14,FOLLOW_140); 
+            otherlv_3=(Token)match(input,14,FOLLOW_141); 
 
                 	newLeafNode(otherlv_3, grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_3());
                 
-            otherlv_4=(Token)match(input,110,FOLLOW_138); 
+            otherlv_4=(Token)match(input,110,FOLLOW_139); 
 
                 	newLeafNode(otherlv_4, grammarAccess.getAnnotationTypeAccess().getTargetKeyword_4());
                 
-            otherlv_5=(Token)match(input,26,FOLLOW_141); 
+            otherlv_5=(Token)match(input,26,FOLLOW_142); 
 
                 	newLeafNode(otherlv_5, grammarAccess.getAnnotationTypeAccess().getEqualsSignKeyword_5());
                 
-            // InternalRoom.g:8039:1: ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) )
-            int alt168=2;
-            int LA168_0 = input.LA(1);
+            // InternalRoom.g:8138:1: ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) )
+            int alt171=2;
+            int LA171_0 = input.LA(1);
 
-            if ( (LA168_0==28||LA168_0==42||LA168_0==48||LA168_0==51||LA168_0==55||LA168_0==59||LA168_0==64||LA168_0==66||LA168_0==79) ) {
-                alt168=1;
+            if ( (LA171_0==28||LA171_0==42||LA171_0==48||LA171_0==51||LA171_0==55||LA171_0==59||LA171_0==64||LA171_0==66||LA171_0==79) ) {
+                alt171=1;
             }
-            else if ( (LA168_0==14) ) {
-                alt168=2;
+            else if ( (LA171_0==14) ) {
+                alt171=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 168, 0, input);
+                    new NoViableAltException("", 171, 0, input);
 
                 throw nvae;
             }
-            switch (alt168) {
+            switch (alt171) {
                 case 1 :
-                    // InternalRoom.g:8039:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8138:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
                     {
-                    // InternalRoom.g:8039:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
-                    // InternalRoom.g:8040:1: (lv_targets_6_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8138:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8139:1: (lv_targets_6_0= ruleAnnotationTargetType )
                     {
-                    // InternalRoom.g:8040:1: (lv_targets_6_0= ruleAnnotationTargetType )
-                    // InternalRoom.g:8041:3: lv_targets_6_0= ruleAnnotationTargetType
+                    // InternalRoom.g:8139:1: (lv_targets_6_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8140:3: lv_targets_6_0= ruleAnnotationTargetType
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); 
                     	    
-                    pushFollow(FOLLOW_142);
+                    pushFollow(FOLLOW_143);
                     lv_targets_6_0=ruleAnnotationTargetType();
 
                     state._fsp--;
@@ -20051,20 +20350,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8058:6: (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' )
+                    // InternalRoom.g:8157:6: (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' )
                     {
-                    // InternalRoom.g:8058:6: (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' )
-                    // InternalRoom.g:8058:8: otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}'
+                    // InternalRoom.g:8157:6: (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' )
+                    // InternalRoom.g:8157:8: otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}'
                     {
-                    otherlv_7=(Token)match(input,14,FOLLOW_143); 
+                    otherlv_7=(Token)match(input,14,FOLLOW_144); 
 
                         	newLeafNode(otherlv_7, grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_6_1_0());
                         
-                    // InternalRoom.g:8062:1: ( (lv_targets_8_0= ruleAnnotationTargetType ) )
-                    // InternalRoom.g:8063:1: (lv_targets_8_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8161:1: ( (lv_targets_8_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8162:1: (lv_targets_8_0= ruleAnnotationTargetType )
                     {
-                    // InternalRoom.g:8063:1: (lv_targets_8_0= ruleAnnotationTargetType )
-                    // InternalRoom.g:8064:3: lv_targets_8_0= ruleAnnotationTargetType
+                    // InternalRoom.g:8162:1: (lv_targets_8_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8163:3: lv_targets_8_0= ruleAnnotationTargetType
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); 
@@ -20091,30 +20390,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:8080:2: (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )*
-                    loop167:
+                    // InternalRoom.g:8179:2: (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )*
+                    loop170:
                     do {
-                        int alt167=2;
-                        int LA167_0 = input.LA(1);
+                        int alt170=2;
+                        int LA170_0 = input.LA(1);
 
-                        if ( (LA167_0==25) ) {
-                            alt167=1;
+                        if ( (LA170_0==25) ) {
+                            alt170=1;
                         }
 
 
-                        switch (alt167) {
+                        switch (alt170) {
                     	case 1 :
-                    	    // InternalRoom.g:8080:4: otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) )
+                    	    // InternalRoom.g:8179:4: otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) )
                     	    {
-                    	    otherlv_9=(Token)match(input,25,FOLLOW_143); 
+                    	    otherlv_9=(Token)match(input,25,FOLLOW_144); 
 
                     	        	newLeafNode(otherlv_9, grammarAccess.getAnnotationTypeAccess().getCommaKeyword_6_1_2_0());
                     	        
-                    	    // InternalRoom.g:8084:1: ( (lv_targets_10_0= ruleAnnotationTargetType ) )
-                    	    // InternalRoom.g:8085:1: (lv_targets_10_0= ruleAnnotationTargetType )
+                    	    // InternalRoom.g:8183:1: ( (lv_targets_10_0= ruleAnnotationTargetType ) )
+                    	    // InternalRoom.g:8184:1: (lv_targets_10_0= ruleAnnotationTargetType )
                     	    {
-                    	    // InternalRoom.g:8085:1: (lv_targets_10_0= ruleAnnotationTargetType )
-                    	    // InternalRoom.g:8086:3: lv_targets_10_0= ruleAnnotationTargetType
+                    	    // InternalRoom.g:8184:1: (lv_targets_10_0= ruleAnnotationTargetType )
+                    	    // InternalRoom.g:8185:3: lv_targets_10_0= ruleAnnotationTargetType
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); 
@@ -20146,11 +20445,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop167;
+                    	    break loop170;
                         }
                     } while (true);
 
-                    otherlv_11=(Token)match(input,15,FOLLOW_142); 
+                    otherlv_11=(Token)match(input,15,FOLLOW_143); 
 
                         	newLeafNode(otherlv_11, grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_6_1_3());
                         
@@ -20163,28 +20462,28 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8106:3: ( (lv_attributes_12_0= ruleAnnotationAttribute ) )*
-            loop169:
+            // InternalRoom.g:8205:3: ( (lv_attributes_12_0= ruleAnnotationAttribute ) )*
+            loop172:
             do {
-                int alt169=2;
-                int LA169_0 = input.LA(1);
+                int alt172=2;
+                int LA172_0 = input.LA(1);
 
-                if ( ((LA169_0>=111 && LA169_0<=112)) ) {
-                    alt169=1;
+                if ( ((LA172_0>=111 && LA172_0<=112)) ) {
+                    alt172=1;
                 }
 
 
-                switch (alt169) {
+                switch (alt172) {
             	case 1 :
-            	    // InternalRoom.g:8107:1: (lv_attributes_12_0= ruleAnnotationAttribute )
+            	    // InternalRoom.g:8206:1: (lv_attributes_12_0= ruleAnnotationAttribute )
             	    {
-            	    // InternalRoom.g:8107:1: (lv_attributes_12_0= ruleAnnotationAttribute )
-            	    // InternalRoom.g:8108:3: lv_attributes_12_0= ruleAnnotationAttribute
+            	    // InternalRoom.g:8206:1: (lv_attributes_12_0= ruleAnnotationAttribute )
+            	    // InternalRoom.g:8207:3: lv_attributes_12_0= ruleAnnotationAttribute
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); 
             	    	    
-            	    pushFollow(FOLLOW_142);
+            	    pushFollow(FOLLOW_143);
             	    lv_attributes_12_0=ruleAnnotationAttribute();
 
             	    state._fsp--;
@@ -20208,7 +20507,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop169;
+            	    break loop172;
                 }
             } while (true);
 
@@ -20237,7 +20536,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalRoom.g:8136:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
+    // InternalRoom.g:8235:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
     public final EObject entryRuleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20245,8 +20544,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8137:2: (iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF )
-            // InternalRoom.g:8138:2: iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF
+            // InternalRoom.g:8236:2: (iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF )
+            // InternalRoom.g:8237:2: iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20273,7 +20572,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleAnnotationAttribute"
-    // InternalRoom.g:8145:1: ruleAnnotationAttribute returns [EObject current=null] : (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) ;
+    // InternalRoom.g:8244:1: ruleAnnotationAttribute returns [EObject current=null] : (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) ;
     public final EObject ruleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20285,114 +20584,114 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8148:28: ( (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) )
-            // InternalRoom.g:8149:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
+            // InternalRoom.g:8247:28: ( (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) )
+            // InternalRoom.g:8248:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
             {
-            // InternalRoom.g:8149:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
-            int alt170=2;
-            int LA170_0 = input.LA(1);
+            // InternalRoom.g:8248:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
+            int alt173=2;
+            int LA173_0 = input.LA(1);
 
-            if ( (LA170_0==111) ) {
-                int LA170_1 = input.LA(2);
+            if ( (LA173_0==111) ) {
+                int LA173_1 = input.LA(2);
 
-                if ( (LA170_1==113) ) {
-                    int LA170_3 = input.LA(3);
+                if ( (LA173_1==113) ) {
+                    int LA173_3 = input.LA(3);
 
-                    if ( (LA170_3==RULE_ID) ) {
-                        int LA170_4 = input.LA(4);
+                    if ( (LA173_3==RULE_ID) ) {
+                        int LA173_4 = input.LA(4);
 
-                        if ( (LA170_4==16) ) {
-                            int LA170_5 = input.LA(5);
+                        if ( (LA173_4==16) ) {
+                            int LA173_5 = input.LA(5);
 
-                            if ( (LA170_5==14) ) {
-                                alt170=2;
+                            if ( (LA173_5==14) ) {
+                                alt173=2;
                             }
-                            else if ( ((LA170_5>=129 && LA170_5<=132)) ) {
-                                alt170=1;
+                            else if ( ((LA173_5>=129 && LA173_5<=132)) ) {
+                                alt173=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 170, 5, input);
+                                    new NoViableAltException("", 173, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 170, 4, input);
+                                new NoViableAltException("", 173, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 170, 3, input);
+                            new NoViableAltException("", 173, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 170, 1, input);
+                        new NoViableAltException("", 173, 1, input);
 
                     throw nvae;
                 }
             }
-            else if ( (LA170_0==112) ) {
-                int LA170_2 = input.LA(2);
+            else if ( (LA173_0==112) ) {
+                int LA173_2 = input.LA(2);
 
-                if ( (LA170_2==113) ) {
-                    int LA170_3 = input.LA(3);
+                if ( (LA173_2==113) ) {
+                    int LA173_3 = input.LA(3);
 
-                    if ( (LA170_3==RULE_ID) ) {
-                        int LA170_4 = input.LA(4);
+                    if ( (LA173_3==RULE_ID) ) {
+                        int LA173_4 = input.LA(4);
 
-                        if ( (LA170_4==16) ) {
-                            int LA170_5 = input.LA(5);
+                        if ( (LA173_4==16) ) {
+                            int LA173_5 = input.LA(5);
 
-                            if ( (LA170_5==14) ) {
-                                alt170=2;
+                            if ( (LA173_5==14) ) {
+                                alt173=2;
                             }
-                            else if ( ((LA170_5>=129 && LA170_5<=132)) ) {
-                                alt170=1;
+                            else if ( ((LA173_5>=129 && LA173_5<=132)) ) {
+                                alt173=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 170, 5, input);
+                                    new NoViableAltException("", 173, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 170, 4, input);
+                                new NoViableAltException("", 173, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 170, 3, input);
+                            new NoViableAltException("", 173, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 170, 2, input);
+                        new NoViableAltException("", 173, 2, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 170, 0, input);
+                    new NoViableAltException("", 173, 0, input);
 
                 throw nvae;
             }
-            switch (alt170) {
+            switch (alt173) {
                 case 1 :
-                    // InternalRoom.g:8150:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
+                    // InternalRoom.g:8249:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
@@ -20410,7 +20709,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8160:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
+                    // InternalRoom.g:8259:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
@@ -20448,7 +20747,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalRoom.g:8176:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
+    // InternalRoom.g:8275:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
     public final EObject entryRuleSimpleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20456,8 +20755,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8177:2: (iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF )
-            // InternalRoom.g:8178:2: iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF
+            // InternalRoom.g:8276:2: (iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF )
+            // InternalRoom.g:8277:2: iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20484,7 +20783,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleSimpleAnnotationAttribute"
-    // InternalRoom.g:8185:1: ruleSimpleAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) ;
+    // InternalRoom.g:8284:1: ruleSimpleAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) ;
     public final EObject ruleSimpleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20499,39 +20798,39 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8188:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) )
-            // InternalRoom.g:8189:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
+            // InternalRoom.g:8287:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) ) )
+            // InternalRoom.g:8288:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
             {
-            // InternalRoom.g:8189:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
-            // InternalRoom.g:8189:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) )
+            // InternalRoom.g:8288:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) ) )
+            // InternalRoom.g:8288:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' ( (lv_type_5_0= ruleLiteralType ) )
             {
-            // InternalRoom.g:8189:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
-            int alt171=2;
-            int LA171_0 = input.LA(1);
+            // InternalRoom.g:8288:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt174=2;
+            int LA174_0 = input.LA(1);
 
-            if ( (LA171_0==111) ) {
-                alt171=1;
+            if ( (LA174_0==111) ) {
+                alt174=1;
             }
-            else if ( (LA171_0==112) ) {
-                alt171=2;
+            else if ( (LA174_0==112) ) {
+                alt174=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 171, 0, input);
+                    new NoViableAltException("", 174, 0, input);
 
                 throw nvae;
             }
-            switch (alt171) {
+            switch (alt174) {
                 case 1 :
-                    // InternalRoom.g:8189:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8288:3: ( (lv_optional_0_0= 'optional' ) )
                     {
-                    // InternalRoom.g:8189:3: ( (lv_optional_0_0= 'optional' ) )
-                    // InternalRoom.g:8190:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8288:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8289:1: (lv_optional_0_0= 'optional' )
                     {
-                    // InternalRoom.g:8190:1: (lv_optional_0_0= 'optional' )
-                    // InternalRoom.g:8191:3: lv_optional_0_0= 'optional'
+                    // InternalRoom.g:8289:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8290:3: lv_optional_0_0= 'optional'
                     {
-                    lv_optional_0_0=(Token)match(input,111,FOLLOW_144); 
+                    lv_optional_0_0=(Token)match(input,111,FOLLOW_145); 
 
                             newLeafNode(lv_optional_0_0, grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0());
                         
@@ -20551,9 +20850,9 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8205:7: otherlv_1= 'mandatory'
+                    // InternalRoom.g:8304:7: otherlv_1= 'mandatory'
                     {
-                    otherlv_1=(Token)match(input,112,FOLLOW_144); 
+                    otherlv_1=(Token)match(input,112,FOLLOW_145); 
 
                         	newLeafNode(otherlv_1, grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1());
                         
@@ -20567,11 +20866,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1());
                 
-            // InternalRoom.g:8213:1: ( (lv_name_3_0= RULE_ID ) )
-            // InternalRoom.g:8214:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8312:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalRoom.g:8313:1: (lv_name_3_0= RULE_ID )
             {
-            // InternalRoom.g:8214:1: (lv_name_3_0= RULE_ID )
-            // InternalRoom.g:8215:3: lv_name_3_0= RULE_ID
+            // InternalRoom.g:8313:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8314:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -20597,11 +20896,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_4, grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3());
                 
-            // InternalRoom.g:8235:1: ( (lv_type_5_0= ruleLiteralType ) )
-            // InternalRoom.g:8236:1: (lv_type_5_0= ruleLiteralType )
+            // InternalRoom.g:8334:1: ( (lv_type_5_0= ruleLiteralType ) )
+            // InternalRoom.g:8335:1: (lv_type_5_0= ruleLiteralType )
             {
-            // InternalRoom.g:8236:1: (lv_type_5_0= ruleLiteralType )
-            // InternalRoom.g:8237:3: lv_type_5_0= ruleLiteralType
+            // InternalRoom.g:8335:1: (lv_type_5_0= ruleLiteralType )
+            // InternalRoom.g:8336:3: lv_type_5_0= ruleLiteralType
             {
              
             	        newCompositeNode(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
@@ -20649,7 +20948,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalRoom.g:8261:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
+    // InternalRoom.g:8360:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
     public final EObject entryRuleEnumAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20657,8 +20956,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8262:2: (iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF )
-            // InternalRoom.g:8263:2: iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF
+            // InternalRoom.g:8361:2: (iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF )
+            // InternalRoom.g:8362:2: iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20685,7 +20984,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleEnumAnnotationAttribute"
-    // InternalRoom.g:8270:1: ruleEnumAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) ;
+    // InternalRoom.g:8369:1: ruleEnumAnnotationAttribute returns [EObject current=null] : ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) ;
     public final EObject ruleEnumAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20703,39 +21002,39 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8273:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) )
-            // InternalRoom.g:8274:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
+            // InternalRoom.g:8372:28: ( ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' ) )
+            // InternalRoom.g:8373:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
             {
-            // InternalRoom.g:8274:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
-            // InternalRoom.g:8274:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}'
+            // InternalRoom.g:8373:1: ( ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}' )
+            // InternalRoom.g:8373:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' ) otherlv_2= 'attribute' ( (lv_name_3_0= RULE_ID ) ) otherlv_4= ':' otherlv_5= '{' ( (lv_values_6_0= RULE_STRING ) ) (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )* otherlv_9= '}'
             {
-            // InternalRoom.g:8274:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
-            int alt172=2;
-            int LA172_0 = input.LA(1);
+            // InternalRoom.g:8373:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt175=2;
+            int LA175_0 = input.LA(1);
 
-            if ( (LA172_0==111) ) {
-                alt172=1;
+            if ( (LA175_0==111) ) {
+                alt175=1;
             }
-            else if ( (LA172_0==112) ) {
-                alt172=2;
+            else if ( (LA175_0==112) ) {
+                alt175=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 172, 0, input);
+                    new NoViableAltException("", 175, 0, input);
 
                 throw nvae;
             }
-            switch (alt172) {
+            switch (alt175) {
                 case 1 :
-                    // InternalRoom.g:8274:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8373:3: ( (lv_optional_0_0= 'optional' ) )
                     {
-                    // InternalRoom.g:8274:3: ( (lv_optional_0_0= 'optional' ) )
-                    // InternalRoom.g:8275:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8373:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8374:1: (lv_optional_0_0= 'optional' )
                     {
-                    // InternalRoom.g:8275:1: (lv_optional_0_0= 'optional' )
-                    // InternalRoom.g:8276:3: lv_optional_0_0= 'optional'
+                    // InternalRoom.g:8374:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8375:3: lv_optional_0_0= 'optional'
                     {
-                    lv_optional_0_0=(Token)match(input,111,FOLLOW_144); 
+                    lv_optional_0_0=(Token)match(input,111,FOLLOW_145); 
 
                             newLeafNode(lv_optional_0_0, grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0());
                         
@@ -20755,9 +21054,9 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8290:7: otherlv_1= 'mandatory'
+                    // InternalRoom.g:8389:7: otherlv_1= 'mandatory'
                     {
-                    otherlv_1=(Token)match(input,112,FOLLOW_144); 
+                    otherlv_1=(Token)match(input,112,FOLLOW_145); 
 
                         	newLeafNode(otherlv_1, grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1());
                         
@@ -20771,11 +21070,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1());
                 
-            // InternalRoom.g:8298:1: ( (lv_name_3_0= RULE_ID ) )
-            // InternalRoom.g:8299:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8397:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalRoom.g:8398:1: (lv_name_3_0= RULE_ID )
             {
-            // InternalRoom.g:8299:1: (lv_name_3_0= RULE_ID )
-            // InternalRoom.g:8300:3: lv_name_3_0= RULE_ID
+            // InternalRoom.g:8398:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8399:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -20805,11 +21104,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_5, grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4());
                 
-            // InternalRoom.g:8324:1: ( (lv_values_6_0= RULE_STRING ) )
-            // InternalRoom.g:8325:1: (lv_values_6_0= RULE_STRING )
+            // InternalRoom.g:8423:1: ( (lv_values_6_0= RULE_STRING ) )
+            // InternalRoom.g:8424:1: (lv_values_6_0= RULE_STRING )
             {
-            // InternalRoom.g:8325:1: (lv_values_6_0= RULE_STRING )
-            // InternalRoom.g:8326:3: lv_values_6_0= RULE_STRING
+            // InternalRoom.g:8424:1: (lv_values_6_0= RULE_STRING )
+            // InternalRoom.g:8425:3: lv_values_6_0= RULE_STRING
             {
             lv_values_6_0=(Token)match(input,RULE_STRING,FOLLOW_20); 
 
@@ -20831,30 +21130,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8342:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
-            loop173:
+            // InternalRoom.g:8441:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
+            loop176:
             do {
-                int alt173=2;
-                int LA173_0 = input.LA(1);
+                int alt176=2;
+                int LA176_0 = input.LA(1);
 
-                if ( (LA173_0==25) ) {
-                    alt173=1;
+                if ( (LA176_0==25) ) {
+                    alt176=1;
                 }
 
 
-                switch (alt173) {
+                switch (alt176) {
             	case 1 :
-            	    // InternalRoom.g:8342:4: otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalRoom.g:8441:4: otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) )
             	    {
             	    otherlv_7=(Token)match(input,25,FOLLOW_12); 
 
             	        	newLeafNode(otherlv_7, grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0());
             	        
-            	    // InternalRoom.g:8346:1: ( (lv_values_8_0= RULE_STRING ) )
-            	    // InternalRoom.g:8347:1: (lv_values_8_0= RULE_STRING )
+            	    // InternalRoom.g:8445:1: ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalRoom.g:8446:1: (lv_values_8_0= RULE_STRING )
             	    {
-            	    // InternalRoom.g:8347:1: (lv_values_8_0= RULE_STRING )
-            	    // InternalRoom.g:8348:3: lv_values_8_0= RULE_STRING
+            	    // InternalRoom.g:8446:1: (lv_values_8_0= RULE_STRING )
+            	    // InternalRoom.g:8447:3: lv_values_8_0= RULE_STRING
             	    {
             	    lv_values_8_0=(Token)match(input,RULE_STRING,FOLLOW_20); 
 
@@ -20881,7 +21180,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop173;
+            	    break loop176;
                 }
             } while (true);
 
@@ -20910,7 +21209,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleImport"
-    // InternalRoom.g:8376:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ;
+    // InternalRoom.g:8475:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ;
     public final EObject entryRuleImport() throws RecognitionException {
         EObject current = null;
 
@@ -20918,8 +21217,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8377:2: (iv_ruleImport= ruleImport EOF )
-            // InternalRoom.g:8378:2: iv_ruleImport= ruleImport EOF
+            // InternalRoom.g:8476:2: (iv_ruleImport= ruleImport EOF )
+            // InternalRoom.g:8477:2: iv_ruleImport= ruleImport EOF
             {
              newCompositeNode(grammarAccess.getImportRule()); 
             pushFollow(FOLLOW_1);
@@ -20946,7 +21245,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleImport"
-    // InternalRoom.g:8385:1: ruleImport returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) ) ;
+    // InternalRoom.g:8484:1: ruleImport returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) ) ;
     public final EObject ruleImport() throws RecognitionException {
         EObject current = null;
 
@@ -20960,49 +21259,49 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8388:28: ( (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) ) )
-            // InternalRoom.g:8389:1: (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) )
+            // InternalRoom.g:8487:28: ( (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) ) )
+            // InternalRoom.g:8488:1: (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) )
             {
-            // InternalRoom.g:8389:1: (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) )
-            // InternalRoom.g:8389:3: otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) )
+            // InternalRoom.g:8488:1: (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) )
+            // InternalRoom.g:8488:3: otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) )
             {
-            otherlv_0=(Token)match(input,114,FOLLOW_145); 
+            otherlv_0=(Token)match(input,114,FOLLOW_146); 
 
                 	newLeafNode(otherlv_0, grammarAccess.getImportAccess().getImportKeyword_0());
                 
-            // InternalRoom.g:8393:1: ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' )
-            int alt174=2;
-            int LA174_0 = input.LA(1);
+            // InternalRoom.g:8492:1: ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' )
+            int alt177=2;
+            int LA177_0 = input.LA(1);
 
-            if ( (LA174_0==RULE_ID) ) {
-                alt174=1;
+            if ( (LA177_0==RULE_ID) ) {
+                alt177=1;
             }
-            else if ( (LA174_0==116) ) {
-                alt174=2;
+            else if ( (LA177_0==116) ) {
+                alt177=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 174, 0, input);
+                    new NoViableAltException("", 177, 0, input);
 
                 throw nvae;
             }
-            switch (alt174) {
+            switch (alt177) {
                 case 1 :
-                    // InternalRoom.g:8393:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
+                    // InternalRoom.g:8492:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
                     {
-                    // InternalRoom.g:8393:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
-                    // InternalRoom.g:8393:3: ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from'
+                    // InternalRoom.g:8492:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
+                    // InternalRoom.g:8492:3: ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from'
                     {
-                    // InternalRoom.g:8393:3: ( (lv_importedNamespace_1_0= ruleImportedFQN ) )
-                    // InternalRoom.g:8394:1: (lv_importedNamespace_1_0= ruleImportedFQN )
+                    // InternalRoom.g:8492:3: ( (lv_importedNamespace_1_0= ruleImportedFQN ) )
+                    // InternalRoom.g:8493:1: (lv_importedNamespace_1_0= ruleImportedFQN )
                     {
-                    // InternalRoom.g:8394:1: (lv_importedNamespace_1_0= ruleImportedFQN )
-                    // InternalRoom.g:8395:3: lv_importedNamespace_1_0= ruleImportedFQN
+                    // InternalRoom.g:8493:1: (lv_importedNamespace_1_0= ruleImportedFQN )
+                    // InternalRoom.g:8494:3: lv_importedNamespace_1_0= ruleImportedFQN
                     {
                      
                     	        newCompositeNode(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); 
                     	    
-                    pushFollow(FOLLOW_146);
+                    pushFollow(FOLLOW_147);
                     lv_importedNamespace_1_0=ruleImportedFQN();
 
                     state._fsp--;
@@ -21035,7 +21334,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8416:7: otherlv_3= 'model'
+                    // InternalRoom.g:8515:7: otherlv_3= 'model'
                     {
                     otherlv_3=(Token)match(input,116,FOLLOW_12); 
 
@@ -21047,11 +21346,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8420:2: ( (lv_importURI_4_0= RULE_STRING ) )
-            // InternalRoom.g:8421:1: (lv_importURI_4_0= RULE_STRING )
+            // InternalRoom.g:8519:2: ( (lv_importURI_4_0= RULE_STRING ) )
+            // InternalRoom.g:8520:1: (lv_importURI_4_0= RULE_STRING )
             {
-            // InternalRoom.g:8421:1: (lv_importURI_4_0= RULE_STRING )
-            // InternalRoom.g:8422:3: lv_importURI_4_0= RULE_STRING
+            // InternalRoom.g:8520:1: (lv_importURI_4_0= RULE_STRING )
+            // InternalRoom.g:8521:3: lv_importURI_4_0= RULE_STRING
             {
             lv_importURI_4_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
 
@@ -21094,7 +21393,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalRoom.g:8446:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
+    // InternalRoom.g:8545:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
     public final String entryRuleImportedFQN() throws RecognitionException {
         String current = null;
 
@@ -21102,8 +21401,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8447:2: (iv_ruleImportedFQN= ruleImportedFQN EOF )
-            // InternalRoom.g:8448:2: iv_ruleImportedFQN= ruleImportedFQN EOF
+            // InternalRoom.g:8546:2: (iv_ruleImportedFQN= ruleImportedFQN EOF )
+            // InternalRoom.g:8547:2: iv_ruleImportedFQN= ruleImportedFQN EOF
             {
              newCompositeNode(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -21130,7 +21429,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleImportedFQN"
-    // InternalRoom.g:8455:1: ruleImportedFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FQN_0= ruleFQN (kw= '.*' )? ) ;
+    // InternalRoom.g:8554:1: ruleImportedFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FQN_0= ruleFQN (kw= '.*' )? ) ;
     public final AntlrDatatypeRuleToken ruleImportedFQN() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -21141,16 +21440,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8458:28: ( (this_FQN_0= ruleFQN (kw= '.*' )? ) )
-            // InternalRoom.g:8459:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
+            // InternalRoom.g:8557:28: ( (this_FQN_0= ruleFQN (kw= '.*' )? ) )
+            // InternalRoom.g:8558:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
             {
-            // InternalRoom.g:8459:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
-            // InternalRoom.g:8460:5: this_FQN_0= ruleFQN (kw= '.*' )?
+            // InternalRoom.g:8558:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
+            // InternalRoom.g:8559:5: this_FQN_0= ruleFQN (kw= '.*' )?
             {
              
                     newCompositeNode(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
                 
-            pushFollow(FOLLOW_147);
+            pushFollow(FOLLOW_148);
             this_FQN_0=ruleFQN();
 
             state._fsp--;
@@ -21161,16 +21460,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
                     afterParserOrEnumRuleCall();
                 
-            // InternalRoom.g:8470:1: (kw= '.*' )?
-            int alt175=2;
-            int LA175_0 = input.LA(1);
+            // InternalRoom.g:8569:1: (kw= '.*' )?
+            int alt178=2;
+            int LA178_0 = input.LA(1);
 
-            if ( (LA175_0==117) ) {
-                alt175=1;
+            if ( (LA178_0==117) ) {
+                alt178=1;
             }
-            switch (alt175) {
+            switch (alt178) {
                 case 1 :
-                    // InternalRoom.g:8471:2: kw= '.*'
+                    // InternalRoom.g:8570:2: kw= '.*'
                     {
                     kw=(Token)match(input,117,FOLLOW_2); 
 
@@ -21204,7 +21503,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalRoom.g:8484:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
+    // InternalRoom.g:8583:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
     public final EObject entryRuleDocumentation() throws RecognitionException {
         EObject current = null;
 
@@ -21212,8 +21511,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8485:2: (iv_ruleDocumentation= ruleDocumentation EOF )
-            // InternalRoom.g:8486:2: iv_ruleDocumentation= ruleDocumentation EOF
+            // InternalRoom.g:8584:2: (iv_ruleDocumentation= ruleDocumentation EOF )
+            // InternalRoom.g:8585:2: iv_ruleDocumentation= ruleDocumentation EOF
             {
              newCompositeNode(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -21240,7 +21539,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDocumentation"
-    // InternalRoom.g:8493:1: ruleDocumentation returns [EObject current=null] : ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) ;
+    // InternalRoom.g:8592:1: ruleDocumentation returns [EObject current=null] : ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) ;
     public final EObject ruleDocumentation() throws RecognitionException {
         EObject current = null;
 
@@ -21251,14 +21550,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8496:28: ( ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) )
-            // InternalRoom.g:8497:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
+            // InternalRoom.g:8595:28: ( ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) )
+            // InternalRoom.g:8596:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
             {
-            // InternalRoom.g:8497:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
-            // InternalRoom.g:8497:2: () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']'
+            // InternalRoom.g:8596:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
+            // InternalRoom.g:8596:2: () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']'
             {
-            // InternalRoom.g:8497:2: ()
-            // InternalRoom.g:8498:5: 
+            // InternalRoom.g:8596:2: ()
+            // InternalRoom.g:8597:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21268,29 +21567,29 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            otherlv_1=(Token)match(input,34,FOLLOW_148); 
+            otherlv_1=(Token)match(input,34,FOLLOW_149); 
 
                 	newLeafNode(otherlv_1, grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1());
                 
-            // InternalRoom.g:8507:1: ( (lv_lines_2_0= RULE_STRING ) )*
-            loop176:
+            // InternalRoom.g:8606:1: ( (lv_lines_2_0= RULE_STRING ) )*
+            loop179:
             do {
-                int alt176=2;
-                int LA176_0 = input.LA(1);
+                int alt179=2;
+                int LA179_0 = input.LA(1);
 
-                if ( (LA176_0==RULE_STRING) ) {
-                    alt176=1;
+                if ( (LA179_0==RULE_STRING) ) {
+                    alt179=1;
                 }
 
 
-                switch (alt176) {
+                switch (alt179) {
             	case 1 :
-            	    // InternalRoom.g:8508:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalRoom.g:8607:1: (lv_lines_2_0= RULE_STRING )
             	    {
-            	    // InternalRoom.g:8508:1: (lv_lines_2_0= RULE_STRING )
-            	    // InternalRoom.g:8509:3: lv_lines_2_0= RULE_STRING
+            	    // InternalRoom.g:8607:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalRoom.g:8608:3: lv_lines_2_0= RULE_STRING
             	    {
-            	    lv_lines_2_0=(Token)match(input,RULE_STRING,FOLLOW_148); 
+            	    lv_lines_2_0=(Token)match(input,RULE_STRING,FOLLOW_149); 
 
             	    			newLeafNode(lv_lines_2_0, grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); 
             	    		
@@ -21312,7 +21611,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop176;
+            	    break loop179;
                 }
             } while (true);
 
@@ -21341,7 +21640,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalRoom.g:8541:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+    // InternalRoom.g:8640:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
     public final EObject entryRuleLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21349,8 +21648,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8542:2: (iv_ruleLiteral= ruleLiteral EOF )
-            // InternalRoom.g:8543:2: iv_ruleLiteral= ruleLiteral EOF
+            // InternalRoom.g:8641:2: (iv_ruleLiteral= ruleLiteral EOF )
+            // InternalRoom.g:8642:2: iv_ruleLiteral= ruleLiteral EOF
             {
              newCompositeNode(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21377,7 +21676,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLiteral"
-    // InternalRoom.g:8550:1: ruleLiteral returns [EObject current=null] : (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) ;
+    // InternalRoom.g:8649:1: ruleLiteral returns [EObject current=null] : (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) ;
     public final EObject ruleLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21391,16 +21690,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8553:28: ( (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) )
-            // InternalRoom.g:8554:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
+            // InternalRoom.g:8652:28: ( (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) )
+            // InternalRoom.g:8653:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
             {
-            // InternalRoom.g:8554:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
-            int alt177=3;
+            // InternalRoom.g:8653:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
+            int alt180=3;
             switch ( input.LA(1) ) {
             case 118:
             case 119:
                 {
-                alt177=1;
+                alt180=1;
                 }
                 break;
             case RULE_INT:
@@ -21408,24 +21707,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             case 120:
             case 121:
                 {
-                alt177=2;
+                alt180=2;
                 }
                 break;
             case RULE_STRING:
                 {
-                alt177=3;
+                alt180=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 177, 0, input);
+                    new NoViableAltException("", 180, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt177) {
+            switch (alt180) {
                 case 1 :
-                    // InternalRoom.g:8555:5: this_BooleanLiteral_0= ruleBooleanLiteral
+                    // InternalRoom.g:8654:5: this_BooleanLiteral_0= ruleBooleanLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
@@ -21443,7 +21742,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8565:5: this_NumberLiteral_1= ruleNumberLiteral
+                    // InternalRoom.g:8664:5: this_NumberLiteral_1= ruleNumberLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
@@ -21461,7 +21760,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:8575:5: this_StringLiteral_2= ruleStringLiteral
+                    // InternalRoom.g:8674:5: this_StringLiteral_2= ruleStringLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
@@ -21499,7 +21798,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalRoom.g:8591:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
+    // InternalRoom.g:8690:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
     public final EObject entryRuleBooleanLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21507,8 +21806,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8592:2: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF )
-            // InternalRoom.g:8593:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF
+            // InternalRoom.g:8691:2: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF )
+            // InternalRoom.g:8692:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF
             {
              newCompositeNode(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21535,7 +21834,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleBooleanLiteral"
-    // InternalRoom.g:8600:1: ruleBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
+    // InternalRoom.g:8699:1: ruleBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
     public final EObject ruleBooleanLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21545,14 +21844,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8603:28: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
-            // InternalRoom.g:8604:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalRoom.g:8702:28: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
+            // InternalRoom.g:8703:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
             {
-            // InternalRoom.g:8604:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
-            // InternalRoom.g:8604:2: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            // InternalRoom.g:8703:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalRoom.g:8703:2: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
             {
-            // InternalRoom.g:8604:2: ()
-            // InternalRoom.g:8605:5: 
+            // InternalRoom.g:8703:2: ()
+            // InternalRoom.g:8704:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21562,25 +21861,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8610:2: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
-            int alt178=2;
-            int LA178_0 = input.LA(1);
+            // InternalRoom.g:8709:2: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            int alt181=2;
+            int LA181_0 = input.LA(1);
 
-            if ( (LA178_0==118) ) {
-                alt178=1;
+            if ( (LA181_0==118) ) {
+                alt181=1;
             }
-            else if ( (LA178_0==119) ) {
-                alt178=2;
+            else if ( (LA181_0==119) ) {
+                alt181=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 178, 0, input);
+                    new NoViableAltException("", 181, 0, input);
 
                 throw nvae;
             }
-            switch (alt178) {
+            switch (alt181) {
                 case 1 :
-                    // InternalRoom.g:8610:4: otherlv_1= 'false'
+                    // InternalRoom.g:8709:4: otherlv_1= 'false'
                     {
                     otherlv_1=(Token)match(input,118,FOLLOW_2); 
 
@@ -21590,13 +21889,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8615:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalRoom.g:8714:6: ( (lv_isTrue_2_0= 'true' ) )
                     {
-                    // InternalRoom.g:8615:6: ( (lv_isTrue_2_0= 'true' ) )
-                    // InternalRoom.g:8616:1: (lv_isTrue_2_0= 'true' )
+                    // InternalRoom.g:8714:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalRoom.g:8715:1: (lv_isTrue_2_0= 'true' )
                     {
-                    // InternalRoom.g:8616:1: (lv_isTrue_2_0= 'true' )
-                    // InternalRoom.g:8617:3: lv_isTrue_2_0= 'true'
+                    // InternalRoom.g:8715:1: (lv_isTrue_2_0= 'true' )
+                    // InternalRoom.g:8716:3: lv_isTrue_2_0= 'true'
                     {
                     lv_isTrue_2_0=(Token)match(input,119,FOLLOW_2); 
 
@@ -21641,7 +21940,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalRoom.g:8638:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
+    // InternalRoom.g:8737:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
     public final EObject entryRuleNumberLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21649,8 +21948,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8639:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
-            // InternalRoom.g:8640:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
+            // InternalRoom.g:8738:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
+            // InternalRoom.g:8739:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
             {
              newCompositeNode(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21677,7 +21976,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleNumberLiteral"
-    // InternalRoom.g:8647:1: ruleNumberLiteral returns [EObject current=null] : (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) ;
+    // InternalRoom.g:8746:1: ruleNumberLiteral returns [EObject current=null] : (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) ;
     public final EObject ruleNumberLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21689,35 +21988,35 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8650:28: ( (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) )
-            // InternalRoom.g:8651:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
+            // InternalRoom.g:8749:28: ( (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) )
+            // InternalRoom.g:8750:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
             {
-            // InternalRoom.g:8651:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
-            int alt179=2;
+            // InternalRoom.g:8750:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
+            int alt182=2;
             switch ( input.LA(1) ) {
             case 120:
                 {
-                int LA179_1 = input.LA(2);
+                int LA182_1 = input.LA(2);
 
-                if ( (LA179_1==RULE_INT) ) {
-                    int LA179_3 = input.LA(3);
+                if ( (LA182_1==RULE_INT) ) {
+                    int LA182_3 = input.LA(3);
 
-                    if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                        alt179=1;
+                    if ( (LA182_3==EOF||LA182_3==21||LA182_3==25) ) {
+                        alt182=1;
                     }
-                    else if ( (LA179_3==72) ) {
-                        alt179=2;
+                    else if ( (LA182_3==72) ) {
+                        alt182=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 179, 3, input);
+                            new NoViableAltException("", 182, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 1, input);
+                        new NoViableAltException("", 182, 1, input);
 
                     throw nvae;
                 }
@@ -21725,27 +22024,27 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 121:
                 {
-                int LA179_2 = input.LA(2);
+                int LA182_2 = input.LA(2);
 
-                if ( (LA179_2==RULE_INT) ) {
-                    int LA179_3 = input.LA(3);
+                if ( (LA182_2==RULE_INT) ) {
+                    int LA182_3 = input.LA(3);
 
-                    if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                        alt179=1;
+                    if ( (LA182_3==EOF||LA182_3==21||LA182_3==25) ) {
+                        alt182=1;
                     }
-                    else if ( (LA179_3==72) ) {
-                        alt179=2;
+                    else if ( (LA182_3==72) ) {
+                        alt182=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 179, 3, input);
+                            new NoViableAltException("", 182, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 2, input);
+                        new NoViableAltException("", 182, 2, input);
 
                     throw nvae;
                 }
@@ -21753,17 +22052,17 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA179_3 = input.LA(2);
+                int LA182_3 = input.LA(2);
 
-                if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                    alt179=1;
+                if ( (LA182_3==EOF||LA182_3==21||LA182_3==25) ) {
+                    alt182=1;
                 }
-                else if ( (LA179_3==72) ) {
-                    alt179=2;
+                else if ( (LA182_3==72) ) {
+                    alt182=2;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 3, input);
+                        new NoViableAltException("", 182, 3, input);
 
                     throw nvae;
                 }
@@ -21771,19 +22070,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_HEX:
                 {
-                alt179=1;
+                alt182=1;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 179, 0, input);
+                    new NoViableAltException("", 182, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt179) {
+            switch (alt182) {
                 case 1 :
-                    // InternalRoom.g:8652:5: this_IntLiteral_0= ruleIntLiteral
+                    // InternalRoom.g:8751:5: this_IntLiteral_0= ruleIntLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
@@ -21801,7 +22100,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8662:5: this_RealLiteral_1= ruleRealLiteral
+                    // InternalRoom.g:8761:5: this_RealLiteral_1= ruleRealLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
@@ -21839,7 +22138,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalRoom.g:8678:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
+    // InternalRoom.g:8777:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
     public final EObject entryRuleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21847,8 +22146,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8679:2: (iv_ruleRealLiteral= ruleRealLiteral EOF )
-            // InternalRoom.g:8680:2: iv_ruleRealLiteral= ruleRealLiteral EOF
+            // InternalRoom.g:8778:2: (iv_ruleRealLiteral= ruleRealLiteral EOF )
+            // InternalRoom.g:8779:2: iv_ruleRealLiteral= ruleRealLiteral EOF
             {
              newCompositeNode(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21875,7 +22174,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleRealLiteral"
-    // InternalRoom.g:8687:1: ruleRealLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleReal ) ) ) ;
+    // InternalRoom.g:8786:1: ruleRealLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleReal ) ) ) ;
     public final EObject ruleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21885,14 +22184,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8690:28: ( ( () ( (lv_value_1_0= ruleReal ) ) ) )
-            // InternalRoom.g:8691:1: ( () ( (lv_value_1_0= ruleReal ) ) )
+            // InternalRoom.g:8789:28: ( ( () ( (lv_value_1_0= ruleReal ) ) ) )
+            // InternalRoom.g:8790:1: ( () ( (lv_value_1_0= ruleReal ) ) )
             {
-            // InternalRoom.g:8691:1: ( () ( (lv_value_1_0= ruleReal ) ) )
-            // InternalRoom.g:8691:2: () ( (lv_value_1_0= ruleReal ) )
+            // InternalRoom.g:8790:1: ( () ( (lv_value_1_0= ruleReal ) ) )
+            // InternalRoom.g:8790:2: () ( (lv_value_1_0= ruleReal ) )
             {
-            // InternalRoom.g:8691:2: ()
-            // InternalRoom.g:8692:5: 
+            // InternalRoom.g:8790:2: ()
+            // InternalRoom.g:8791:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21902,11 +22201,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8697:2: ( (lv_value_1_0= ruleReal ) )
-            // InternalRoom.g:8698:1: (lv_value_1_0= ruleReal )
+            // InternalRoom.g:8796:2: ( (lv_value_1_0= ruleReal ) )
+            // InternalRoom.g:8797:1: (lv_value_1_0= ruleReal )
             {
-            // InternalRoom.g:8698:1: (lv_value_1_0= ruleReal )
-            // InternalRoom.g:8699:3: lv_value_1_0= ruleReal
+            // InternalRoom.g:8797:1: (lv_value_1_0= ruleReal )
+            // InternalRoom.g:8798:3: lv_value_1_0= ruleReal
             {
              
             	        newCompositeNode(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
@@ -21954,7 +22253,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalRoom.g:8723:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
+    // InternalRoom.g:8822:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
     public final EObject entryRuleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21962,8 +22261,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8724:2: (iv_ruleIntLiteral= ruleIntLiteral EOF )
-            // InternalRoom.g:8725:2: iv_ruleIntLiteral= ruleIntLiteral EOF
+            // InternalRoom.g:8823:2: (iv_ruleIntLiteral= ruleIntLiteral EOF )
+            // InternalRoom.g:8824:2: iv_ruleIntLiteral= ruleIntLiteral EOF
             {
              newCompositeNode(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21990,7 +22289,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleIntLiteral"
-    // InternalRoom.g:8732:1: ruleIntLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleInteger ) ) ) ;
+    // InternalRoom.g:8831:1: ruleIntLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleInteger ) ) ) ;
     public final EObject ruleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22000,14 +22299,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8735:28: ( ( () ( (lv_value_1_0= ruleInteger ) ) ) )
-            // InternalRoom.g:8736:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
+            // InternalRoom.g:8834:28: ( ( () ( (lv_value_1_0= ruleInteger ) ) ) )
+            // InternalRoom.g:8835:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
             {
-            // InternalRoom.g:8736:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
-            // InternalRoom.g:8736:2: () ( (lv_value_1_0= ruleInteger ) )
+            // InternalRoom.g:8835:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
+            // InternalRoom.g:8835:2: () ( (lv_value_1_0= ruleInteger ) )
             {
-            // InternalRoom.g:8736:2: ()
-            // InternalRoom.g:8737:5: 
+            // InternalRoom.g:8835:2: ()
+            // InternalRoom.g:8836:5: 
             {
 
                     current = forceCreateModelElement(
@@ -22017,11 +22316,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8742:2: ( (lv_value_1_0= ruleInteger ) )
-            // InternalRoom.g:8743:1: (lv_value_1_0= ruleInteger )
+            // InternalRoom.g:8841:2: ( (lv_value_1_0= ruleInteger ) )
+            // InternalRoom.g:8842:1: (lv_value_1_0= ruleInteger )
             {
-            // InternalRoom.g:8743:1: (lv_value_1_0= ruleInteger )
-            // InternalRoom.g:8744:3: lv_value_1_0= ruleInteger
+            // InternalRoom.g:8842:1: (lv_value_1_0= ruleInteger )
+            // InternalRoom.g:8843:3: lv_value_1_0= ruleInteger
             {
              
             	        newCompositeNode(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
@@ -22069,7 +22368,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalRoom.g:8768:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
+    // InternalRoom.g:8867:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
     public final EObject entryRuleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22077,8 +22376,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8769:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
-            // InternalRoom.g:8770:2: iv_ruleStringLiteral= ruleStringLiteral EOF
+            // InternalRoom.g:8868:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
+            // InternalRoom.g:8869:2: iv_ruleStringLiteral= ruleStringLiteral EOF
             {
              newCompositeNode(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -22105,7 +22404,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStringLiteral"
-    // InternalRoom.g:8777:1: ruleStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
+    // InternalRoom.g:8876:1: ruleStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
     public final EObject ruleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22114,14 +22413,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8780:28: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
-            // InternalRoom.g:8781:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalRoom.g:8879:28: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
+            // InternalRoom.g:8880:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
             {
-            // InternalRoom.g:8781:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
-            // InternalRoom.g:8781:2: () ( (lv_value_1_0= RULE_STRING ) )
+            // InternalRoom.g:8880:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalRoom.g:8880:2: () ( (lv_value_1_0= RULE_STRING ) )
             {
-            // InternalRoom.g:8781:2: ()
-            // InternalRoom.g:8782:5: 
+            // InternalRoom.g:8880:2: ()
+            // InternalRoom.g:8881:5: 
             {
 
                     current = forceCreateModelElement(
@@ -22131,11 +22430,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8787:2: ( (lv_value_1_0= RULE_STRING ) )
-            // InternalRoom.g:8788:1: (lv_value_1_0= RULE_STRING )
+            // InternalRoom.g:8886:2: ( (lv_value_1_0= RULE_STRING ) )
+            // InternalRoom.g:8887:1: (lv_value_1_0= RULE_STRING )
             {
-            // InternalRoom.g:8788:1: (lv_value_1_0= RULE_STRING )
-            // InternalRoom.g:8789:3: lv_value_1_0= RULE_STRING
+            // InternalRoom.g:8887:1: (lv_value_1_0= RULE_STRING )
+            // InternalRoom.g:8888:3: lv_value_1_0= RULE_STRING
             {
             lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
 
@@ -22178,7 +22477,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalRoom.g:8813:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
+    // InternalRoom.g:8912:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
     public final String entryRuleInteger() throws RecognitionException {
         String current = null;
 
@@ -22186,8 +22485,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8814:2: (iv_ruleInteger= ruleInteger EOF )
-            // InternalRoom.g:8815:2: iv_ruleInteger= ruleInteger EOF
+            // InternalRoom.g:8913:2: (iv_ruleInteger= ruleInteger EOF )
+            // InternalRoom.g:8914:2: iv_ruleInteger= ruleInteger EOF
             {
              newCompositeNode(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -22214,7 +22513,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleInteger"
-    // InternalRoom.g:8822:1: ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) ;
+    // InternalRoom.g:8921:1: ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) ;
     public final AntlrDatatypeRuleToken ruleInteger() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -22225,45 +22524,45 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8825:28: ( ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) )
-            // InternalRoom.g:8826:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
+            // InternalRoom.g:8924:28: ( ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) )
+            // InternalRoom.g:8925:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
             {
-            // InternalRoom.g:8826:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
-            int alt181=2;
-            int LA181_0 = input.LA(1);
+            // InternalRoom.g:8925:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
+            int alt184=2;
+            int LA184_0 = input.LA(1);
 
-            if ( (LA181_0==RULE_INT||(LA181_0>=120 && LA181_0<=121)) ) {
-                alt181=1;
+            if ( (LA184_0==RULE_INT||(LA184_0>=120 && LA184_0<=121)) ) {
+                alt184=1;
             }
-            else if ( (LA181_0==RULE_HEX) ) {
-                alt181=2;
+            else if ( (LA184_0==RULE_HEX) ) {
+                alt184=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 181, 0, input);
+                    new NoViableAltException("", 184, 0, input);
 
                 throw nvae;
             }
-            switch (alt181) {
+            switch (alt184) {
                 case 1 :
-                    // InternalRoom.g:8826:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalRoom.g:8925:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
                     {
-                    // InternalRoom.g:8826:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
-                    // InternalRoom.g:8826:3: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT
+                    // InternalRoom.g:8925:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalRoom.g:8925:3: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT
                     {
-                    // InternalRoom.g:8826:3: (kw= '+' | kw= '-' )?
-                    int alt180=3;
-                    int LA180_0 = input.LA(1);
+                    // InternalRoom.g:8925:3: (kw= '+' | kw= '-' )?
+                    int alt183=3;
+                    int LA183_0 = input.LA(1);
 
-                    if ( (LA180_0==120) ) {
-                        alt180=1;
+                    if ( (LA183_0==120) ) {
+                        alt183=1;
                     }
-                    else if ( (LA180_0==121) ) {
-                        alt180=2;
+                    else if ( (LA183_0==121) ) {
+                        alt183=2;
                     }
-                    switch (alt180) {
+                    switch (alt183) {
                         case 1 :
-                            // InternalRoom.g:8827:2: kw= '+'
+                            // InternalRoom.g:8926:2: kw= '+'
                             {
                             kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22274,7 +22573,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:8834:2: kw= '-'
+                            // InternalRoom.g:8933:2: kw= '-'
                             {
                             kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22301,7 +22600,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8847:10: this_HEX_3= RULE_HEX
+                    // InternalRoom.g:8946:10: this_HEX_3= RULE_HEX
                     {
                     this_HEX_3=(Token)match(input,RULE_HEX,FOLLOW_2); 
 
@@ -22334,7 +22633,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalRoom.g:8862:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
+    // InternalRoom.g:8961:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
     public final String entryRuleReal() throws RecognitionException {
         String current = null;
 
@@ -22342,8 +22641,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:8863:2: (iv_ruleReal= ruleReal EOF )
-            // InternalRoom.g:8864:2: iv_ruleReal= ruleReal EOF
+            // InternalRoom.g:8962:2: (iv_ruleReal= ruleReal EOF )
+            // InternalRoom.g:8963:2: iv_ruleReal= ruleReal EOF
             {
              newCompositeNode(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -22370,7 +22669,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleReal"
-    // InternalRoom.g:8871:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) ;
+    // InternalRoom.g:8970:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) ;
     public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -22382,55 +22681,55 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:8874:28: ( (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) )
-            // InternalRoom.g:8875:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
+            // InternalRoom.g:8973:28: ( (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) )
+            // InternalRoom.g:8974:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
             {
-            // InternalRoom.g:8875:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
-            int alt182=2;
+            // InternalRoom.g:8974:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
+            int alt185=2;
             switch ( input.LA(1) ) {
             case 120:
                 {
-                int LA182_1 = input.LA(2);
+                int LA185_1 = input.LA(2);
 
-                if ( (LA182_1==RULE_INT) ) {
-                    int LA182_3 = input.LA(3);
+                if ( (LA185_1==RULE_INT) ) {
+                    int LA185_3 = input.LA(3);
 
-                    if ( (LA182_3==72) ) {
-                        int LA182_4 = input.LA(4);
+                    if ( (LA185_3==72) ) {
+                        int LA185_4 = input.LA(4);
 
-                        if ( (LA182_4==RULE_INT) ) {
-                            int LA182_5 = input.LA(5);
+                        if ( (LA185_4==RULE_INT) ) {
+                            int LA185_5 = input.LA(5);
 
-                            if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                                alt182=1;
+                            if ( (LA185_5==EOF||LA185_5==21||LA185_5==25) ) {
+                                alt185=1;
                             }
-                            else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                                alt182=2;
+                            else if ( ((LA185_5>=122 && LA185_5<=123)) ) {
+                                alt185=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 182, 5, input);
+                                    new NoViableAltException("", 185, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 4, input);
+                                new NoViableAltException("", 185, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 3, input);
+                            new NoViableAltException("", 185, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 1, input);
+                        new NoViableAltException("", 185, 1, input);
 
                     throw nvae;
                 }
@@ -22438,47 +22737,47 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 121:
                 {
-                int LA182_2 = input.LA(2);
+                int LA185_2 = input.LA(2);
 
-                if ( (LA182_2==RULE_INT) ) {
-                    int LA182_3 = input.LA(3);
+                if ( (LA185_2==RULE_INT) ) {
+                    int LA185_3 = input.LA(3);
 
-                    if ( (LA182_3==72) ) {
-                        int LA182_4 = input.LA(4);
+                    if ( (LA185_3==72) ) {
+                        int LA185_4 = input.LA(4);
 
-                        if ( (LA182_4==RULE_INT) ) {
-                            int LA182_5 = input.LA(5);
+                        if ( (LA185_4==RULE_INT) ) {
+                            int LA185_5 = input.LA(5);
 
-                            if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                                alt182=1;
+                            if ( (LA185_5==EOF||LA185_5==21||LA185_5==25) ) {
+                                alt185=1;
                             }
-                            else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                                alt182=2;
+                            else if ( ((LA185_5>=122 && LA185_5<=123)) ) {
+                                alt185=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 182, 5, input);
+                                    new NoViableAltException("", 185, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 4, input);
+                                new NoViableAltException("", 185, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 3, input);
+                            new NoViableAltException("", 185, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 2, input);
+                        new NoViableAltException("", 185, 2, input);
 
                     throw nvae;
                 }
@@ -22486,37 +22785,37 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA182_3 = input.LA(2);
+                int LA185_3 = input.LA(2);
 
-                if ( (LA182_3==72) ) {
-                    int LA182_4 = input.LA(3);
+                if ( (LA185_3==72) ) {
+                    int LA185_4 = input.LA(3);
 
-                    if ( (LA182_4==RULE_INT) ) {
-                        int LA182_5 = input.LA(4);
+                    if ( (LA185_4==RULE_INT) ) {
+                        int LA185_5 = input.LA(4);
 
-                        if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                            alt182=1;
+                        if ( (LA185_5==EOF||LA185_5==21||LA185_5==25) ) {
+                            alt185=1;
                         }
-                        else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                            alt182=2;
+                        else if ( ((LA185_5>=122 && LA185_5<=123)) ) {
+                            alt185=2;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 5, input);
+                                new NoViableAltException("", 185, 5, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 4, input);
+                            new NoViableAltException("", 185, 4, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 3, input);
+                        new NoViableAltException("", 185, 3, input);
 
                     throw nvae;
                 }
@@ -22524,14 +22823,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 182, 0, input);
+                    new NoViableAltException("", 185, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt182) {
+            switch (alt185) {
                 case 1 :
-                    // InternalRoom.g:8876:5: this_Decimal_0= ruleDecimal
+                    // InternalRoom.g:8975:5: this_Decimal_0= ruleDecimal
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
@@ -22551,7 +22850,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8888:5: this_DecimalExp_1= ruleDecimalExp
+                    // InternalRoom.g:8987:5: this_DecimalExp_1= ruleDecimalExp
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
@@ -22591,7 +22890,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalRoom.g:8906:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
+    // InternalRoom.g:9005:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
     public final String entryRuleDecimal() throws RecognitionException {
         String current = null;
 
@@ -22602,8 +22901,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         	
         try {
-            // InternalRoom.g:8910:2: (iv_ruleDecimal= ruleDecimal EOF )
-            // InternalRoom.g:8911:2: iv_ruleDecimal= ruleDecimal EOF
+            // InternalRoom.g:9009:2: (iv_ruleDecimal= ruleDecimal EOF )
+            // InternalRoom.g:9010:2: iv_ruleDecimal= ruleDecimal EOF
             {
              newCompositeNode(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -22633,7 +22932,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDecimal"
-    // InternalRoom.g:8921:1: ruleDecimal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) ;
+    // InternalRoom.g:9020:1: ruleDecimal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) ;
     public final AntlrDatatypeRuleToken ruleDecimal() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -22645,25 +22944,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
             
         try {
-            // InternalRoom.g:8925:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) )
-            // InternalRoom.g:8926:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
+            // InternalRoom.g:9024:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) )
+            // InternalRoom.g:9025:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
             {
-            // InternalRoom.g:8926:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
-            // InternalRoom.g:8926:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT
+            // InternalRoom.g:9025:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
+            // InternalRoom.g:9025:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT
             {
-            // InternalRoom.g:8926:2: (kw= '+' | kw= '-' )?
-            int alt183=3;
-            int LA183_0 = input.LA(1);
+            // InternalRoom.g:9025:2: (kw= '+' | kw= '-' )?
+            int alt186=3;
+            int LA186_0 = input.LA(1);
 
-            if ( (LA183_0==120) ) {
-                alt183=1;
+            if ( (LA186_0==120) ) {
+                alt186=1;
             }
-            else if ( (LA183_0==121) ) {
-                alt183=2;
+            else if ( (LA186_0==121) ) {
+                alt186=2;
             }
-            switch (alt183) {
+            switch (alt186) {
                 case 1 :
-                    // InternalRoom.g:8927:2: kw= '+'
+                    // InternalRoom.g:9026:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22674,7 +22973,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8934:2: kw= '-'
+                    // InternalRoom.g:9033:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22687,7 +22986,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            this_INT_2=(Token)match(input,RULE_INT,FOLLOW_101); 
+            this_INT_2=(Token)match(input,RULE_INT,FOLLOW_102); 
 
             		current.merge(this_INT_2);
                 
@@ -22730,7 +23029,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalRoom.g:8970:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
+    // InternalRoom.g:9069:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
     public final String entryRuleDecimalExp() throws RecognitionException {
         String current = null;
 
@@ -22741,8 +23040,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
         	
         try {
-            // InternalRoom.g:8974:2: (iv_ruleDecimalExp= ruleDecimalExp EOF )
-            // InternalRoom.g:8975:2: iv_ruleDecimalExp= ruleDecimalExp EOF
+            // InternalRoom.g:9073:2: (iv_ruleDecimalExp= ruleDecimalExp EOF )
+            // InternalRoom.g:9074:2: iv_ruleDecimalExp= ruleDecimalExp EOF
             {
              newCompositeNode(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -22772,7 +23071,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleDecimalExp"
-    // InternalRoom.g:8985:1: ruleDecimalExp returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) ;
+    // InternalRoom.g:9084:1: ruleDecimalExp returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) ;
     public final AntlrDatatypeRuleToken ruleDecimalExp() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -22785,25 +23084,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
         		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
             
         try {
-            // InternalRoom.g:8989:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) )
-            // InternalRoom.g:8990:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
+            // InternalRoom.g:9088:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT ) )
+            // InternalRoom.g:9089:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
             {
-            // InternalRoom.g:8990:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
-            // InternalRoom.g:8990:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT
+            // InternalRoom.g:9089:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT )
+            // InternalRoom.g:9089:2: (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT (kw= 'e' | kw= 'E' ) (kw= '+' | kw= '-' )? this_INT_9= RULE_INT
             {
-            // InternalRoom.g:8990:2: (kw= '+' | kw= '-' )?
-            int alt184=3;
-            int LA184_0 = input.LA(1);
+            // InternalRoom.g:9089:2: (kw= '+' | kw= '-' )?
+            int alt187=3;
+            int LA187_0 = input.LA(1);
 
-            if ( (LA184_0==120) ) {
-                alt184=1;
+            if ( (LA187_0==120) ) {
+                alt187=1;
             }
-            else if ( (LA184_0==121) ) {
-                alt184=2;
+            else if ( (LA187_0==121) ) {
+                alt187=2;
             }
-            switch (alt184) {
+            switch (alt187) {
                 case 1 :
-                    // InternalRoom.g:8991:2: kw= '+'
+                    // InternalRoom.g:9090:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22814,7 +23113,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8998:2: kw= '-'
+                    // InternalRoom.g:9097:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22827,7 +23126,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            this_INT_2=(Token)match(input,RULE_INT,FOLLOW_101); 
+            this_INT_2=(Token)match(input,RULE_INT,FOLLOW_102); 
 
             		current.merge(this_INT_2);
                 
@@ -22839,34 +23138,34 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     current.merge(kw);
                     newLeafNode(kw, grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); 
                 
-            this_INT_4=(Token)match(input,RULE_INT,FOLLOW_149); 
+            this_INT_4=(Token)match(input,RULE_INT,FOLLOW_150); 
 
             		current.merge(this_INT_4);
                 
              
                 newLeafNode(this_INT_4, grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); 
                 
-            // InternalRoom.g:9023:1: (kw= 'e' | kw= 'E' )
-            int alt185=2;
-            int LA185_0 = input.LA(1);
+            // InternalRoom.g:9122:1: (kw= 'e' | kw= 'E' )
+            int alt188=2;
+            int LA188_0 = input.LA(1);
 
-            if ( (LA185_0==122) ) {
-                alt185=1;
+            if ( (LA188_0==122) ) {
+                alt188=1;
             }
-            else if ( (LA185_0==123) ) {
-                alt185=2;
+            else if ( (LA188_0==123) ) {
+                alt188=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 185, 0, input);
+                    new NoViableAltException("", 188, 0, input);
 
                 throw nvae;
             }
-            switch (alt185) {
+            switch (alt188) {
                 case 1 :
-                    // InternalRoom.g:9024:2: kw= 'e'
+                    // InternalRoom.g:9123:2: kw= 'e'
                     {
-                    kw=(Token)match(input,122,FOLLOW_150); 
+                    kw=(Token)match(input,122,FOLLOW_151); 
 
                             current.merge(kw);
                             newLeafNode(kw, grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); 
@@ -22875,9 +23174,9 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9031:2: kw= 'E'
+                    // InternalRoom.g:9130:2: kw= 'E'
                     {
-                    kw=(Token)match(input,123,FOLLOW_150); 
+                    kw=(Token)match(input,123,FOLLOW_151); 
 
                             current.merge(kw);
                             newLeafNode(kw, grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); 
@@ -22888,19 +23187,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:9036:2: (kw= '+' | kw= '-' )?
-            int alt186=3;
-            int LA186_0 = input.LA(1);
+            // InternalRoom.g:9135:2: (kw= '+' | kw= '-' )?
+            int alt189=3;
+            int LA189_0 = input.LA(1);
 
-            if ( (LA186_0==120) ) {
-                alt186=1;
+            if ( (LA189_0==120) ) {
+                alt189=1;
             }
-            else if ( (LA186_0==121) ) {
-                alt186=2;
+            else if ( (LA189_0==121) ) {
+                alt189=2;
             }
-            switch (alt186) {
+            switch (alt189) {
                 case 1 :
-                    // InternalRoom.g:9037:2: kw= '+'
+                    // InternalRoom.g:9136:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22911,7 +23210,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9044:2: kw= '-'
+                    // InternalRoom.g:9143:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22955,7 +23254,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalRoom.g:9067:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
+    // InternalRoom.g:9166:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
     public final String entryRuleFQN() throws RecognitionException {
         String current = null;
 
@@ -22963,8 +23262,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
         try {
-            // InternalRoom.g:9068:2: (iv_ruleFQN= ruleFQN EOF )
-            // InternalRoom.g:9069:2: iv_ruleFQN= ruleFQN EOF
+            // InternalRoom.g:9167:2: (iv_ruleFQN= ruleFQN EOF )
+            // InternalRoom.g:9168:2: iv_ruleFQN= ruleFQN EOF
             {
              newCompositeNode(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -22991,7 +23290,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleFQN"
-    // InternalRoom.g:9076:1: ruleFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) ;
+    // InternalRoom.g:9175:1: ruleFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) ;
     public final AntlrDatatypeRuleToken ruleFQN() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -23002,40 +23301,40 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
          enterRule(); 
             
         try {
-            // InternalRoom.g:9079:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
-            // InternalRoom.g:9080:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
+            // InternalRoom.g:9178:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
+            // InternalRoom.g:9179:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
             {
-            // InternalRoom.g:9080:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
-            // InternalRoom.g:9080:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
+            // InternalRoom.g:9179:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
+            // InternalRoom.g:9179:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
             {
-            this_ID_0=(Token)match(input,RULE_ID,FOLLOW_151); 
+            this_ID_0=(Token)match(input,RULE_ID,FOLLOW_152); 
 
             		current.merge(this_ID_0);
                 
              
                 newLeafNode(this_ID_0, grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
                 
-            // InternalRoom.g:9087:1: (kw= '.' this_ID_2= RULE_ID )*
-            loop187:
+            // InternalRoom.g:9186:1: (kw= '.' this_ID_2= RULE_ID )*
+            loop190:
             do {
-                int alt187=2;
-                int LA187_0 = input.LA(1);
+                int alt190=2;
+                int LA190_0 = input.LA(1);
 
-                if ( (LA187_0==72) ) {
-                    alt187=1;
+                if ( (LA190_0==72) ) {
+                    alt190=1;
                 }
 
 
-                switch (alt187) {
+                switch (alt190) {
             	case 1 :
-            	    // InternalRoom.g:9088:2: kw= '.' this_ID_2= RULE_ID
+            	    // InternalRoom.g:9187:2: kw= '.' this_ID_2= RULE_ID
             	    {
             	    kw=(Token)match(input,72,FOLLOW_3); 
 
             	            current.merge(kw);
             	            newLeafNode(kw, grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); 
             	        
-            	    this_ID_2=(Token)match(input,RULE_ID,FOLLOW_151); 
+            	    this_ID_2=(Token)match(input,RULE_ID,FOLLOW_152); 
 
             	    		current.merge(this_ID_2);
             	        
@@ -23047,7 +23346,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop187;
+            	    break loop190;
                 }
             } while (true);
 
@@ -23072,7 +23371,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleCommunicationType"
-    // InternalRoom.g:9108:1: ruleCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) ) ;
+    // InternalRoom.g:9207:1: ruleCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) ) ;
     public final Enumerator ruleCommunicationType() throws RecognitionException {
         Enumerator current = null;
 
@@ -23082,40 +23381,40 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalRoom.g:9110:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) ) )
-            // InternalRoom.g:9111:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) )
+            // InternalRoom.g:9209:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) ) )
+            // InternalRoom.g:9210:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) )
             {
-            // InternalRoom.g:9111:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) )
-            int alt188=3;
+            // InternalRoom.g:9210:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) )
+            int alt191=3;
             switch ( input.LA(1) ) {
             case 124:
                 {
-                alt188=1;
+                alt191=1;
                 }
                 break;
             case 125:
                 {
-                alt188=2;
+                alt191=2;
                 }
                 break;
             case 126:
                 {
-                alt188=3;
+                alt191=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 188, 0, input);
+                    new NoViableAltException("", 191, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt188) {
+            switch (alt191) {
                 case 1 :
-                    // InternalRoom.g:9111:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9210:2: (enumLiteral_0= 'eventdriven' )
                     {
-                    // InternalRoom.g:9111:2: (enumLiteral_0= 'eventdriven' )
-                    // InternalRoom.g:9111:4: enumLiteral_0= 'eventdriven'
+                    // InternalRoom.g:9210:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9210:4: enumLiteral_0= 'eventdriven'
                     {
                     enumLiteral_0=(Token)match(input,124,FOLLOW_2); 
 
@@ -23129,10 +23428,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9117:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9216:6: (enumLiteral_1= 'datadriven' )
                     {
-                    // InternalRoom.g:9117:6: (enumLiteral_1= 'datadriven' )
-                    // InternalRoom.g:9117:8: enumLiteral_1= 'datadriven'
+                    // InternalRoom.g:9216:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9216:8: enumLiteral_1= 'datadriven'
                     {
                     enumLiteral_1=(Token)match(input,125,FOLLOW_2); 
 
@@ -23146,10 +23445,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9123:6: (enumLiteral_2= 'sync' )
+                    // InternalRoom.g:9222:6: (enumLiteral_2= 'sync' )
                     {
-                    // InternalRoom.g:9123:6: (enumLiteral_2= 'sync' )
-                    // InternalRoom.g:9123:8: enumLiteral_2= 'sync'
+                    // InternalRoom.g:9222:6: (enumLiteral_2= 'sync' )
+                    // InternalRoom.g:9222:8: enumLiteral_2= 'sync'
                     {
                     enumLiteral_2=(Token)match(input,126,FOLLOW_2); 
 
@@ -23183,7 +23482,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleReferenceType"
-    // InternalRoom.g:9133:1: ruleReferenceType returns [Enumerator current=null] : ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) ;
+    // InternalRoom.g:9232:1: ruleReferenceType returns [Enumerator current=null] : ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) ;
     public final Enumerator ruleReferenceType() throws RecognitionException {
         Enumerator current = null;
 
@@ -23192,31 +23491,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalRoom.g:9135:28: ( ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) )
-            // InternalRoom.g:9136:1: ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) )
+            // InternalRoom.g:9234:28: ( ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) )
+            // InternalRoom.g:9235:1: ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) )
             {
-            // InternalRoom.g:9136:1: ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) )
-            int alt189=2;
-            int LA189_0 = input.LA(1);
+            // InternalRoom.g:9235:1: ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) )
+            int alt192=2;
+            int LA192_0 = input.LA(1);
 
-            if ( (LA189_0==127) ) {
-                alt189=1;
+            if ( (LA192_0==127) ) {
+                alt192=1;
             }
-            else if ( (LA189_0==111) ) {
-                alt189=2;
+            else if ( (LA192_0==111) ) {
+                alt192=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 189, 0, input);
+                    new NoViableAltException("", 192, 0, input);
 
                 throw nvae;
             }
-            switch (alt189) {
+            switch (alt192) {
                 case 1 :
-                    // InternalRoom.g:9136:2: (enumLiteral_0= 'fixed' )
+                    // InternalRoom.g:9235:2: (enumLiteral_0= 'fixed' )
                     {
-                    // InternalRoom.g:9136:2: (enumLiteral_0= 'fixed' )
-                    // InternalRoom.g:9136:4: enumLiteral_0= 'fixed'
+                    // InternalRoom.g:9235:2: (enumLiteral_0= 'fixed' )
+                    // InternalRoom.g:9235:4: enumLiteral_0= 'fixed'
                     {
                     enumLiteral_0=(Token)match(input,127,FOLLOW_2); 
 
@@ -23230,10 +23529,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9142:6: (enumLiteral_1= 'optional' )
+                    // InternalRoom.g:9241:6: (enumLiteral_1= 'optional' )
                     {
-                    // InternalRoom.g:9142:6: (enumLiteral_1= 'optional' )
-                    // InternalRoom.g:9142:8: enumLiteral_1= 'optional'
+                    // InternalRoom.g:9241:6: (enumLiteral_1= 'optional' )
+                    // InternalRoom.g:9241:8: enumLiteral_1= 'optional'
                     {
                     enumLiteral_1=(Token)match(input,111,FOLLOW_2); 
 
@@ -23267,7 +23566,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleComponentCommunicationType"
-    // InternalRoom.g:9154:1: ruleComponentCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) ;
+    // InternalRoom.g:9253:1: ruleComponentCommunicationType returns [Enumerator current=null] : ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) ;
     public final Enumerator ruleComponentCommunicationType() throws RecognitionException {
         Enumerator current = null;
 
@@ -23278,45 +23577,45 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalRoom.g:9156:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) )
-            // InternalRoom.g:9157:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
+            // InternalRoom.g:9255:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) )
+            // InternalRoom.g:9256:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
             {
-            // InternalRoom.g:9157:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
-            int alt190=4;
+            // InternalRoom.g:9256:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
+            int alt193=4;
             switch ( input.LA(1) ) {
             case 124:
                 {
-                alt190=1;
+                alt193=1;
                 }
                 break;
             case 125:
                 {
-                alt190=2;
+                alt193=2;
                 }
                 break;
             case 128:
                 {
-                alt190=3;
+                alt193=3;
                 }
                 break;
             case 126:
                 {
-                alt190=4;
+                alt193=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 190, 0, input);
+                    new NoViableAltException("", 193, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt190) {
+            switch (alt193) {
                 case 1 :
-                    // InternalRoom.g:9157:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9256:2: (enumLiteral_0= 'eventdriven' )
                     {
-                    // InternalRoom.g:9157:2: (enumLiteral_0= 'eventdriven' )
-                    // InternalRoom.g:9157:4: enumLiteral_0= 'eventdriven'
+                    // InternalRoom.g:9256:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9256:4: enumLiteral_0= 'eventdriven'
                     {
                     enumLiteral_0=(Token)match(input,124,FOLLOW_2); 
 
@@ -23330,10 +23629,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9163:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9262:6: (enumLiteral_1= 'datadriven' )
                     {
-                    // InternalRoom.g:9163:6: (enumLiteral_1= 'datadriven' )
-                    // InternalRoom.g:9163:8: enumLiteral_1= 'datadriven'
+                    // InternalRoom.g:9262:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9262:8: enumLiteral_1= 'datadriven'
                     {
                     enumLiteral_1=(Token)match(input,125,FOLLOW_2); 
 
@@ -23347,10 +23646,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9169:6: (enumLiteral_2= 'async' )
+                    // InternalRoom.g:9268:6: (enumLiteral_2= 'async' )
                     {
-                    // InternalRoom.g:9169:6: (enumLiteral_2= 'async' )
-                    // InternalRoom.g:9169:8: enumLiteral_2= 'async'
+                    // InternalRoom.g:9268:6: (enumLiteral_2= 'async' )
+                    // InternalRoom.g:9268:8: enumLiteral_2= 'async'
                     {
                     enumLiteral_2=(Token)match(input,128,FOLLOW_2); 
 
@@ -23364,10 +23663,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:9175:6: (enumLiteral_3= 'sync' )
+                    // InternalRoom.g:9274:6: (enumLiteral_3= 'sync' )
                     {
-                    // InternalRoom.g:9175:6: (enumLiteral_3= 'sync' )
-                    // InternalRoom.g:9175:8: enumLiteral_3= 'sync'
+                    // InternalRoom.g:9274:6: (enumLiteral_3= 'sync' )
+                    // InternalRoom.g:9274:8: enumLiteral_3= 'sync'
                     {
                     enumLiteral_3=(Token)match(input,126,FOLLOW_2); 
 
@@ -23401,7 +23700,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleLiteralType"
-    // InternalRoom.g:9185:1: ruleLiteralType returns [Enumerator current=null] : ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) ;
+    // InternalRoom.g:9284:1: ruleLiteralType returns [Enumerator current=null] : ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) ;
     public final Enumerator ruleLiteralType() throws RecognitionException {
         Enumerator current = null;
 
@@ -23412,45 +23711,45 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
          enterRule(); 
         try {
-            // InternalRoom.g:9187:28: ( ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) )
-            // InternalRoom.g:9188:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
+            // InternalRoom.g:9286:28: ( ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) )
+            // InternalRoom.g:9287:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
             {
-            // InternalRoom.g:9188:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
-            int alt191=4;
+            // InternalRoom.g:9287:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
+            int alt194=4;
             switch ( input.LA(1) ) {
             case 129:
                 {
-                alt191=1;
+                alt194=1;
                 }
                 break;
             case 130:
                 {
-                alt191=2;
+                alt194=2;
                 }
                 break;
             case 131:
                 {
-                alt191=3;
+                alt194=3;
                 }
                 break;
             case 132:
                 {
-                alt191=4;
+                alt194=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 191, 0, input);
+                    new NoViableAltException("", 194, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt191) {
+            switch (alt194) {
                 case 1 :
-                    // InternalRoom.g:9188:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalRoom.g:9287:2: (enumLiteral_0= 'ptBoolean' )
                     {
-                    // InternalRoom.g:9188:2: (enumLiteral_0= 'ptBoolean' )
-                    // InternalRoom.g:9188:4: enumLiteral_0= 'ptBoolean'
+                    // InternalRoom.g:9287:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalRoom.g:9287:4: enumLiteral_0= 'ptBoolean'
                     {
                     enumLiteral_0=(Token)match(input,129,FOLLOW_2); 
 
@@ -23464,10 +23763,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9194:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalRoom.g:9293:6: (enumLiteral_1= 'ptInteger' )
                     {
-                    // InternalRoom.g:9194:6: (enumLiteral_1= 'ptInteger' )
-                    // InternalRoom.g:9194:8: enumLiteral_1= 'ptInteger'
+                    // InternalRoom.g:9293:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalRoom.g:9293:8: enumLiteral_1= 'ptInteger'
                     {
                     enumLiteral_1=(Token)match(input,130,FOLLOW_2); 
 
@@ -23481,10 +23780,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9200:6: (enumLiteral_2= 'ptReal' )
+                    // InternalRoom.g:9299:6: (enumLiteral_2= 'ptReal' )
                     {
-                    // InternalRoom.g:9200:6: (enumLiteral_2= 'ptReal' )
-                    // InternalRoom.g:9200:8: enumLiteral_2= 'ptReal'
+                    // InternalRoom.g:9299:6: (enumLiteral_2= 'ptReal' )
+                    // InternalRoom.g:9299:8: enumLiteral_2= 'ptReal'
                     {
                     enumLiteral_2=(Token)match(input,131,FOLLOW_2); 
 
@@ -23498,10 +23797,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:9206:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalRoom.g:9305:6: (enumLiteral_3= 'ptCharacter' )
                     {
-                    // InternalRoom.g:9206:6: (enumLiteral_3= 'ptCharacter' )
-                    // InternalRoom.g:9206:8: enumLiteral_3= 'ptCharacter'
+                    // InternalRoom.g:9305:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalRoom.g:9305:8: enumLiteral_3= 'ptCharacter'
                     {
                     enumLiteral_3=(Token)match(input,132,FOLLOW_2); 
 
@@ -23537,8 +23836,8 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     protected DFA3 dfa3 = new DFA3(this);
-    protected DFA132 dfa132 = new DFA132(this);
-    protected DFA133 dfa133 = new DFA133(this);
+    protected DFA135 dfa135 = new DFA135(this);
+    protected DFA136 dfa136 = new DFA136(this);
     static final String dfa_1s = "\16\uffff";
     static final String dfa_2s = "\1\17\5\uffff\3\52\5\uffff";
     static final String dfa_3s = "\1\u0080\5\uffff\3\u0080\5\uffff";
@@ -23586,38 +23885,38 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
         }
     }
     static final String dfa_7s = "\32\uffff";
-    static final String dfa_8s = "\13\uffff\1\21\7\uffff\2\21\1\uffff\1\21\2\uffff\1\21";
-    static final String dfa_9s = "\1\134\1\4\1\20\1\4\1\23\4\4\2\23\1\16\2\4\1\23\1\5\1\17\1\uffff\1\4\2\16\1\5\1\16\2\uffff\1\16";
-    static final String dfa_10s = "\1\134\2\20\1\145\1\30\2\4\1\145\1\4\2\23\1\143\2\4\1\23\1\43\1\142\1\uffff\1\4\2\143\1\43\1\143\2\uffff\1\143";
-    static final String dfa_11s = "\21\uffff\1\2\5\uffff\1\1\1\3\1\uffff";
+    static final String dfa_8s = "\14\uffff\1\22\6\uffff\3\22\1\uffff\1\22\2\uffff";
+    static final String dfa_9s = "\1\134\1\4\1\20\1\4\1\23\4\4\3\23\1\16\3\4\1\5\1\17\1\uffff\3\16\1\5\1\16\2\uffff";
+    static final String dfa_10s = "\1\134\2\20\1\145\1\30\3\4\1\145\3\23\1\143\3\4\1\43\1\142\1\uffff\3\143\1\43\1\143\2\uffff";
+    static final String dfa_11s = "\22\uffff\1\2\5\uffff\1\1\1\3";
     static final String dfa_12s = "\32\uffff}>";
     static final String[] dfa_13s = {
             "\1\1",
             "\1\2\13\uffff\1\3",
             "\1\3",
             "\1\4\137\uffff\1\5\1\6",
-            "\1\7\4\uffff\1\10",
+            "\1\10\4\uffff\1\7",
             "\1\11",
             "\1\12",
-            "\1\13\137\uffff\1\14\1\15",
-            "\1\16",
-            "\1\7",
-            "\1\7",
-            "\1\20\1\21\10\uffff\1\22\11\uffff\1\17\56\uffff\1\21\4\uffff\7\21\6\uffff\1\21",
+            "\1\13",
+            "\1\14\137\uffff\1\15\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
+            "\1\21\1\22\10\uffff\1\17\11\uffff\1\20\56\uffff\1\22\4\uffff\7\22\6\uffff\1\22",
             "\1\23",
             "\1\24",
-            "\1\7",
-            "\1\25\35\uffff\1\26",
-            "\1\21\116\uffff\1\21\1\27\1\uffff\1\27\1\30",
-            "",
-            "\1\31",
-            "\1\20\1\21\22\uffff\1\17\56\uffff\1\21\4\uffff\7\21\6\uffff\1\21",
-            "\1\20\1\21\22\uffff\1\17\56\uffff\1\21\4\uffff\7\21\6\uffff\1\21",
-            "\1\25\35\uffff\1\26",
-            "\1\20\1\21\101\uffff\1\21\4\uffff\7\21\6\uffff\1\21",
+            "\1\25",
+            "\1\26\35\uffff\1\27",
+            "\1\22\116\uffff\1\22\1\30\1\uffff\1\30\1\31",
             "",
+            "\1\21\1\22\22\uffff\1\20\56\uffff\1\22\4\uffff\7\22\6\uffff\1\22",
+            "\1\21\1\22\22\uffff\1\20\56\uffff\1\22\4\uffff\7\22\6\uffff\1\22",
+            "\1\21\1\22\22\uffff\1\20\56\uffff\1\22\4\uffff\7\22\6\uffff\1\22",
+            "\1\26\35\uffff\1\27",
+            "\1\21\1\22\101\uffff\1\22\4\uffff\7\22\6\uffff\1\22",
             "",
-            "\1\20\1\21\22\uffff\1\17\56\uffff\1\21\4\uffff\7\21\6\uffff\1\21"
+            ""
     };
 
     static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
@@ -23628,11 +23927,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
     static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
 
-    class DFA132 extends DFA {
+    class DFA135 extends DFA {
 
-        public DFA132(BaseRecognizer recognizer) {
+        public DFA135(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 132;
+            this.decisionNumber = 135;
             this.eot = dfa_7;
             this.eof = dfa_8;
             this.min = dfa_9;
@@ -23642,13 +23941,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             this.transition = dfa_13;
         }
         public String getDescription() {
-            return "6178:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )";
+            return "6277:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )";
         }
     }
     static final String dfa_14s = "\31\uffff";
-    static final String dfa_15s = "\1\134\1\4\1\20\1\4\1\23\4\4\3\23\1\16\2\4\1\5\1\137\1\4\2\16\1\5\1\16\2\uffff\1\16";
-    static final String dfa_16s = "\1\134\2\20\1\145\1\30\3\4\1\145\3\23\1\42\2\4\1\43\1\141\1\4\2\42\1\43\1\16\2\uffff\1\42";
-    static final String dfa_17s = "\26\uffff\1\2\1\1\1\uffff";
+    static final String dfa_15s = "\1\134\1\4\1\20\1\4\1\23\4\4\3\23\1\16\3\4\1\5\1\137\3\16\1\5\1\16\2\uffff";
+    static final String dfa_16s = "\1\134\2\20\1\145\1\30\3\4\1\145\3\23\1\42\3\4\1\43\1\141\3\42\1\43\1\16\2\uffff";
+    static final String dfa_17s = "\27\uffff\1\1\1\2";
     static final String dfa_18s = "\31\uffff}>";
     static final String[] dfa_19s = {
             "\1\1",
@@ -23663,19 +23962,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             "\1\10",
             "\1\10",
             "\1\10",
-            "\1\20\11\uffff\1\21\11\uffff\1\17",
+            "\1\21\11\uffff\1\17\11\uffff\1\20",
             "\1\22",
             "\1\23",
-            "\1\24\35\uffff\1\25",
-            "\1\27\1\uffff\1\26",
-            "\1\30",
-            "\1\20\23\uffff\1\17",
-            "\1\20\23\uffff\1\17",
-            "\1\24\35\uffff\1\25",
-            "\1\20",
-            "",
+            "\1\24",
+            "\1\25\35\uffff\1\26",
+            "\1\27\1\uffff\1\30",
+            "\1\21\23\uffff\1\20",
+            "\1\21\23\uffff\1\20",
+            "\1\21\23\uffff\1\20",
+            "\1\25\35\uffff\1\26",
+            "\1\21",
             "",
-            "\1\20\23\uffff\1\17"
+            ""
     };
 
     static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s);
@@ -23685,11 +23984,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
     static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s);
 
-    class DFA133 extends DFA {
+    class DFA136 extends DFA {
 
-        public DFA133(BaseRecognizer recognizer) {
+        public DFA136(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 133;
+            this.decisionNumber = 136;
             this.eot = dfa_14;
             this.eof = dfa_14;
             this.min = dfa_15;
@@ -23699,7 +23998,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             this.transition = dfa_19;
         }
         public String getDescription() {
-            return "6228:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )";
+            return "6327:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )";
         }
     }
  
@@ -23768,92 +24067,93 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0002000000008000L,0x0000100000000000L});
     public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0002000000008000L});
     public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0008000000000000L});
-    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000400000002L,0x0000100000000000L});
-    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0030033200008000L});
-    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x002003320000C080L});
-    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0020033200008000L});
-    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000080000000000L});
-    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000100000000000L});
-    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x00C0000000000000L,0x7000000000000000L,0x0000000000000001L});
-    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0700000000008000L,0x0000100000000000L});
-    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x4800800000008000L});
-    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0600000000008000L});
-    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0xF8008333C0008000L,0x8000800000002440L});
-    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xF80083338000C080L,0x8000800000002440L});
-    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0xF800833380008000L,0x8000800000002440L});
-    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0xF80083330000C080L,0x8000800000002440L});
-    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0xF800833300008000L,0x8000800000002440L});
-    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0xF80083320000C080L,0x8000800000002440L});
-    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0xF800833200008000L,0x8000800000002440L});
-    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0400000000008000L});
-    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000033000008000L,0x0000100000010000L});
-    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000033000008000L,0x0000000000010000L});
-    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0800000000000000L});
-    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000001000000L});
-    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000008000L,0x0000100000000442L});
-    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000442L});
-    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x48008001C0008000L,0x8000900000002458L});
-    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x480080018000C080L,0x8000800000002458L});
-    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x4800800180008000L,0x8000800000002458L});
-    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x480080010000C080L,0x8000800000002458L});
-    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x4800800100008000L,0x8000800000002458L});
-    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x480080000000C080L,0x8000800000002458L});
-    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x4800800000008000L,0x8000800000002458L});
-    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000004002L});
-    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000010L});
-    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
-    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000010002L});
-    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
-    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
-    public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});
-    public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0000000000020000L,0x0000000000001000L});
-    public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
-    public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
-    public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000000000040L,0x0000000000004000L});
-    public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000000008000L,0x000000081FC20000L});
-    public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000400004002L});
-    public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000000008000L,0x00000000003C0000L});
-    public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x000000000000C080L,0x0000000000380000L});
-    public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000000008000L,0x0000000000380000L});
-    public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x000000000000C080L,0x0000000000300000L});
-    public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000008000L,0x0000000000300000L});
-    public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x000000000000C080L,0x0000000000200000L});
-    public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000000008000L,0x0000000000200000L});
-    public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000008020L});
-    public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
-    public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000000010010L});
-    public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
-    public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000000000010L,0x0000003000000000L});
-    public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000000008000L,0x0000000040000000L});
-    public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x000000000000C080L});
-    public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});
-    public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L});
-    public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000000008000L,0x0000000100000000L});
-    public static final BitSet FOLLOW_126 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
-    public static final BitSet FOLLOW_127 = new BitSet(new long[]{0x000000000000C080L,0x0000000040000000L});
-    public static final BitSet FOLLOW_128 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
-    public static final BitSet FOLLOW_129 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
-    public static final BitSet FOLLOW_130 = new BitSet(new long[]{0x0000000000000000L,0x0000018200000000L});
-    public static final BitSet FOLLOW_131 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L});
-    public static final BitSet FOLLOW_132 = new BitSet(new long[]{0x0000000000008000L,0x00000C0000000000L});
-    public static final BitSet FOLLOW_133 = new BitSet(new long[]{0x0000000000080002L});
-    public static final BitSet FOLLOW_134 = new BitSet(new long[]{0x0000000000100000L,0x00000C0000000000L});
-    public static final BitSet FOLLOW_135 = new BitSet(new long[]{0x0000000000000000L,0x00000C0000000000L});
-    public static final BitSet FOLLOW_136 = new BitSet(new long[]{0x0000000002000000L});
-    public static final BitSet FOLLOW_137 = new BitSet(new long[]{0x0000000000100002L});
-    public static final BitSet FOLLOW_138 = new BitSet(new long[]{0x0000000004000000L});
-    public static final BitSet FOLLOW_139 = new BitSet(new long[]{0x0000000000000160L,0x03C0000000000000L});
-    public static final BitSet FOLLOW_140 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
-    public static final BitSet FOLLOW_141 = new BitSet(new long[]{0x0889040010004000L,0x0000000000008005L});
-    public static final BitSet FOLLOW_142 = new BitSet(new long[]{0x0000000000008000L,0x0001800000000000L});
-    public static final BitSet FOLLOW_143 = new BitSet(new long[]{0x0889040010000000L,0x0000000000008005L});
-    public static final BitSet FOLLOW_144 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
-    public static final BitSet FOLLOW_145 = new BitSet(new long[]{0x0000000000000010L,0x0010000000000000L});
-    public static final BitSet FOLLOW_146 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L});
-    public static final BitSet FOLLOW_147 = new BitSet(new long[]{0x0000000000000002L,0x0020000000000000L});
-    public static final BitSet FOLLOW_148 = new BitSet(new long[]{0x0000000800000020L});
-    public static final BitSet FOLLOW_149 = new BitSet(new long[]{0x0000000000000000L,0x0C00000000000000L});
-    public static final BitSet FOLLOW_150 = new BitSet(new long[]{0x0000000000000040L,0x0300000000000000L});
-    public static final BitSet FOLLOW_151 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
+    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000400100002L,0x0000100000000000L});
+    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000400000002L,0x0000100000000000L});
+    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0030033200008000L});
+    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x002003320000C080L});
+    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0020033200008000L});
+    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000080000000000L});
+    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000100000000000L});
+    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x00C0000000000000L,0x7000000000000000L,0x0000000000000001L});
+    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0700000000008000L,0x0000100000000000L});
+    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x4800800000008000L});
+    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0600000000008000L});
+    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xF8008333C0008000L,0x8000800000002440L});
+    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0xF80083338000C080L,0x8000800000002440L});
+    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0xF800833380008000L,0x8000800000002440L});
+    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0xF80083330000C080L,0x8000800000002440L});
+    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0xF800833300008000L,0x8000800000002440L});
+    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0xF80083320000C080L,0x8000800000002440L});
+    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0xF800833200008000L,0x8000800000002440L});
+    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0400000000008000L});
+    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000033000008000L,0x0000100000010000L});
+    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000033000008000L,0x0000000000010000L});
+    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0800000000000000L});
+    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000001000000L});
+    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000008000L,0x0000100000000442L});
+    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000442L});
+    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x48008001C0008000L,0x8000900000002458L});
+    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x480080018000C080L,0x8000800000002458L});
+    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x4800800180008000L,0x8000800000002458L});
+    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x480080010000C080L,0x8000800000002458L});
+    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x4800800100008000L,0x8000800000002458L});
+    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x480080000000C080L,0x8000800000002458L});
+    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x4800800000008000L,0x8000800000002458L});
+    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000004002L});
+    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000010L});
+    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
+    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000010002L});
+    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+    public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
+    public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});
+    public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000000000020000L,0x0000000000001000L});
+    public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
+    public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
+    public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000000000040L,0x0000000000004000L});
+    public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000000008000L,0x000000081FC20000L});
+    public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000400004002L});
+    public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000000000008000L,0x00000000003C0000L});
+    public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x000000000000C080L,0x0000000000380000L});
+    public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000000008000L,0x0000000000380000L});
+    public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x000000000000C080L,0x0000000000300000L});
+    public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0000000000008000L,0x0000000000300000L});
+    public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x000000000000C080L,0x0000000000200000L});
+    public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000008000L,0x0000000000200000L});
+    public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000008020L});
+    public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
+    public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000010010L});
+    public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
+    public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000000000010L,0x0000003000000000L});
+    public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000008000L,0x0000000040000000L});
+    public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x000000000000C080L});
+    public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});
+    public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L});
+    public static final BitSet FOLLOW_126 = new BitSet(new long[]{0x0000000000008000L,0x0000000100000000L});
+    public static final BitSet FOLLOW_127 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
+    public static final BitSet FOLLOW_128 = new BitSet(new long[]{0x000000000000C080L,0x0000000040000000L});
+    public static final BitSet FOLLOW_129 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
+    public static final BitSet FOLLOW_130 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
+    public static final BitSet FOLLOW_131 = new BitSet(new long[]{0x0000000000000000L,0x0000018200000000L});
+    public static final BitSet FOLLOW_132 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L});
+    public static final BitSet FOLLOW_133 = new BitSet(new long[]{0x0000000000008000L,0x00000C0000000000L});
+    public static final BitSet FOLLOW_134 = new BitSet(new long[]{0x0000000000080002L});
+    public static final BitSet FOLLOW_135 = new BitSet(new long[]{0x0000000000100000L,0x00000C0000000000L});
+    public static final BitSet FOLLOW_136 = new BitSet(new long[]{0x0000000000000000L,0x00000C0000000000L});
+    public static final BitSet FOLLOW_137 = new BitSet(new long[]{0x0000000002000000L});
+    public static final BitSet FOLLOW_138 = new BitSet(new long[]{0x0000000000100002L});
+    public static final BitSet FOLLOW_139 = new BitSet(new long[]{0x0000000004000000L});
+    public static final BitSet FOLLOW_140 = new BitSet(new long[]{0x0000000000000160L,0x03C0000000000000L});
+    public static final BitSet FOLLOW_141 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
+    public static final BitSet FOLLOW_142 = new BitSet(new long[]{0x0889040010004000L,0x0000000000008005L});
+    public static final BitSet FOLLOW_143 = new BitSet(new long[]{0x0000000000008000L,0x0001800000000000L});
+    public static final BitSet FOLLOW_144 = new BitSet(new long[]{0x0889040010000000L,0x0000000000008005L});
+    public static final BitSet FOLLOW_145 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
+    public static final BitSet FOLLOW_146 = new BitSet(new long[]{0x0000000000000010L,0x0010000000000000L});
+    public static final BitSet FOLLOW_147 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L});
+    public static final BitSet FOLLOW_148 = new BitSet(new long[]{0x0000000000000002L,0x0020000000000000L});
+    public static final BitSet FOLLOW_149 = new BitSet(new long[]{0x0000000800000020L});
+    public static final BitSet FOLLOW_150 = new BitSet(new long[]{0x0000000000000000L,0x0C00000000000000L});
+    public static final BitSet FOLLOW_151 = new BitSet(new long[]{0x0000000000000040L,0x0300000000000000L});
+    public static final BitSet FOLLOW_152 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 
 }
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorClass.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorClass.java
index 894236fa6..dc22ef74e 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorClass.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorClass.java
@@ -275,7 +275,7 @@ public interface ActorClass extends ActorContainerClass, ModelComponent
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList<Port> ports = new BasicEList<Port>();\r\nfor (ExternalPort ep : getExternalPorts()) {\r\n\tports.add(ep.getInterfacePort());\r\n}\r\nreturn ports;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList&lt;Port&gt; ports = new BasicEList&lt;Port&gt;();\r\nfor (ExternalPort ep : getExternalPorts()) {\r\n\tif(ep.getInterfacePort() != null)\r\n\t\tports.add(ep.getInterfacePort());\r\n}\r\nreturn ports;\r\n'"
    * @generated
    */
   EList<Port> getExternalEndPorts();
@@ -284,7 +284,7 @@ public interface ActorClass extends ActorContainerClass, ModelComponent
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList<Port> ports = new BasicEList<Port>(getInterfacePorts());\r\nfor (ExternalPort ep : getExternalPorts()) {\r\n\tports.remove(ep.getInterfacePort());\r\n}\r\nreturn ports;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList&lt;Port&gt; ports = new BasicEList&lt;Port&gt;(getInterfacePorts());\r\nfor (ExternalPort ep : getExternalPorts()) {\r\n\tif(ep.getInterfacePort() != null)\r\n\t\tports.remove(ep.getInterfacePort());\r\n}\r\nreturn ports;\r\n'"
    * @generated
    */
   EList<Port> getRelayPorts();
@@ -293,7 +293,7 @@ public interface ActorClass extends ActorContainerClass, ModelComponent
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList<SPP> spps = new BasicEList<SPP>();\r\nfor (ServiceImplementation spp : getServiceImplementations()) {\r\n\tspps.add(spp.getSpp());\r\n}\r\nreturn spps;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='EList&lt;SPP&gt; spps = new BasicEList&lt;SPP&gt;();\r\nfor (ServiceImplementation spp : getServiceImplementations()) {\r\n\tif(spp.getSpp() != null)\r\n\t\tspps.add(spp.getSpp());\r\n}\r\nreturn spps;\r\n'"
    * @generated
    */
   EList<SPP> getImplementedSPPs();
@@ -320,7 +320,7 @@ public interface ActorClass extends ActorContainerClass, ModelComponent
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new <%org.eclipse.emf.common.util.BasicEList%><AbstractInterfaceItem>(new <%org.eclipse.etrice.core.room.util.RoomHelpers%>().getInterfaceItems(this));\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new &lt;%org.eclipse.emf.common.util.BasicEList%&gt;&lt;AbstractInterfaceItem&gt;(new &lt;%org.eclipse.etrice.core.room.util.RoomHelpers%&gt;().getInterfaceItems(this));\r\n'"
    * @generated
    */
   EList<AbstractInterfaceItem> getAbstractInterfaceItems();
@@ -329,7 +329,7 @@ public interface ActorClass extends ActorContainerClass, ModelComponent
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new <%org.eclipse.emf.common.util.BasicEList%><AbstractInterfaceItem>(new <%org.eclipse.etrice.core.room.util.RoomHelpers%>().getAllInterfaceItems(this));\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new &lt;%org.eclipse.emf.common.util.BasicEList%&gt;&lt;AbstractInterfaceItem&gt;(new &lt;%org.eclipse.etrice.core.room.util.RoomHelpers%&gt;().getAllInterfaceItems(this));\r\n'"
    * @generated
    */
   EList<AbstractInterfaceItem> getAllAbstractInterfaceItems();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorContainerRef.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorContainerRef.java
index 13d718c98..6d471c2f3 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorContainerRef.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/ActorContainerRef.java
@@ -91,7 +91,7 @@ public interface ActorContainerRef extends EObject
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof <%org.eclipse.etrice.core.room.ActorRef%>)\r\n\treturn ((ActorRef)this).getType();\r\nelse if (this instanceof <%org.eclipse.etrice.core.room.SubSystemRef%>)\r\n\treturn ((SubSystemRef)this).getType();\r\nelse\r\n\treturn null;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof &lt;%org.eclipse.etrice.core.room.ActorRef%&gt;)\r\n\treturn ((ActorRef)this).getType();\r\nelse if (this instanceof &lt;%org.eclipse.etrice.core.room.SubSystemRef%&gt;)\r\n\treturn ((SubSystemRef)this).getType();\r\nelse\r\n\treturn null;\r\n'"
    * @generated
    */
   StructureClass getStructureClass();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/EnumLiteral.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/EnumLiteral.java
index 9b57b4ae2..64cd00704 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/EnumLiteral.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/EnumLiteral.java
@@ -88,7 +88,7 @@ public interface EnumLiteral extends EObject
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this.getLiteral() != null)\r\n\treturn this.getLiteral().getValue();\r\n\r\n// recursively from predecessor\r\n<%org.eclipse.etrice.core.room.EnumerationType%> et = ((EnumerationType) this.eContainer());\r\nint idx = et.getLiterals().indexOf(this);\r\nif (idx > 0)\r\n\treturn et.getLiterals().get(idx - 1).getLiteralValue() + 1;\r\n\r\nreturn 0;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this.getLiteral() != null)\r\n\treturn this.getLiteral().getValue();\r\n\r\n// recursively from predecessor\r\n&lt;%org.eclipse.etrice.core.room.EnumerationType%&gt; et = ((EnumerationType) this.eContainer());\r\nint idx = et.getLiterals().indexOf(this);\r\nif (idx &gt; 0)\r\n\treturn et.getLiterals().get(idx - 1).getLiteralValue() + 1;\r\n\r\nreturn 0;\r\n'"
    * @generated
    */
   long getLiteralValue();
@@ -97,7 +97,7 @@ public interface EnumLiteral extends EObject
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='<%org.eclipse.etrice.core.room.EnumerationType%> et = ((EnumerationType) this.eContainer());\r\nreturn et.getName() + \".\" + this.getName();\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='&lt;%org.eclipse.etrice.core.room.EnumerationType%&gt; et = ((EnumerationType) this.eContainer());\r\nreturn et.getName() + \".\" + this.getName();\r\n'"
    * @generated
    */
   String getFullName();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/InterfaceItem.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/InterfaceItem.java
index cd6a80fbe..4a08be14f 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/InterfaceItem.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/InterfaceItem.java
@@ -37,7 +37,7 @@ public interface InterfaceItem extends AbstractInterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof <%org.eclipse.etrice.core.room.Port%>)\r\n\treturn ((Port) this).getProtocol();\r\nelse if (this instanceof <%org.eclipse.etrice.core.room.SAP%>)\r\n\treturn ((SAP) this).getProtocol();\r\nelse if (this instanceof <%org.eclipse.etrice.core.room.SPP%>)\r\n\treturn ((SPP) this).getProtocol();\r\nreturn null;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (this instanceof &lt;%org.eclipse.etrice.core.room.Port%&gt;)\r\n\treturn ((Port) this).getProtocol();\r\nelse if (this instanceof &lt;%org.eclipse.etrice.core.room.SAP%&gt;)\r\n\treturn ((SAP) this).getProtocol();\r\nelse if (this instanceof &lt;%org.eclipse.etrice.core.room.SPP%&gt;)\r\n\treturn ((SPP) this).getProtocol();\r\nreturn null;\r\n'"
    * @generated
    */
   GeneralProtocolClass getGeneralProtocol();
@@ -46,7 +46,7 @@ public interface InterfaceItem extends AbstractInterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (getGeneralProtocol() instanceof <%org.eclipse.etrice.core.room.ProtocolClass%>)\r\n\treturn ((ProtocolClass)getGeneralProtocol()).getSemantics();\r\nelse\r\n\treturn null;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (getGeneralProtocol() instanceof &lt;%org.eclipse.etrice.core.room.ProtocolClass%&gt;)\r\n\treturn ((ProtocolClass)getGeneralProtocol()).getSemantics();\r\nelse\r\n\treturn null;\r\n'"
    * @generated
    */
   ProtocolSemantics getSemantics();
@@ -55,7 +55,7 @@ public interface InterfaceItem extends AbstractInterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new <%org.eclipse.emf.common.util.BasicEList%><EObject>(new <%org.eclipse.etrice.core.room.util.RoomHelpers%>().getMessageListDeep(this, false));\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new &lt;%org.eclipse.emf.common.util.BasicEList%&gt;&lt;EObject&gt;(new &lt;%org.eclipse.etrice.core.room.util.RoomHelpers%&gt;().getMessageListDeep(this, false));\r\n'"
    * @generated
    */
   EList<EObject> getAllIncomingAbstractMessages();
@@ -64,7 +64,7 @@ public interface InterfaceItem extends AbstractInterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new <%org.eclipse.emf.common.util.BasicEList%><EObject>(new <%org.eclipse.etrice.core.room.util.RoomHelpers%>().getMessageListDeep(this, true));\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return new &lt;%org.eclipse.emf.common.util.BasicEList%&gt;&lt;EObject&gt;(new &lt;%org.eclipse.etrice.core.room.util.RoomHelpers%&gt;().getMessageListDeep(this, true));\r\n'"
    * @generated
    */
   EList<EObject> getAllOutgoingAbstractMessages();
@@ -73,7 +73,7 @@ public interface InterfaceItem extends AbstractInterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (getGeneralProtocol() instanceof ProtocolClass)\r\n    return ((ProtocolClass) getGeneralProtocol()).getCommType() == <%org.eclipse.etrice.core.room.CommunicationType%>.EVENT_DRIVEN;\r\nelse\r\n    return false;\r\n'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='if (getGeneralProtocol() instanceof ProtocolClass)\r\n    return ((ProtocolClass) getGeneralProtocol()).getCommType() == &lt;%org.eclipse.etrice.core.room.CommunicationType%&gt;.EVENT_DRIVEN;\r\nelse\r\n    return false;\r\n'"
    * @generated
    */
   boolean isEventDriven();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Message.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Message.java
index e0ada6091..bf9eaa387 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Message.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Message.java
@@ -103,12 +103,12 @@ public interface Message extends EObject
    * 
    * <!-- end-model-doc -->
    * @return the value of the '<em>Data</em>' containment reference.
-   * @see #setData(VarDecl)
+   * @see #setData(MessageData)
    * @see org.eclipse.etrice.core.room.RoomPackage#getMessage_Data()
    * @model containment="true"
    * @generated
    */
-  VarDecl getData();
+  MessageData getData();
 
   /**
    * Sets the value of the '{@link org.eclipse.etrice.core.room.Message#getData <em>Data</em>}' containment reference.
@@ -118,7 +118,7 @@ public interface Message extends EObject
    * @see #getData()
    * @generated
    */
-  void setData(VarDecl value);
+  void setData(MessageData value);
 
   /**
    * Returns the value of the '<em><b>Annotations</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/MessageData.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/MessageData.java
new file mode 100644
index 000000000..a60d55dc9
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/MessageData.java
@@ -0,0 +1,78 @@
+/**
+ */
+package org.eclipse.etrice.core.room;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Message Data</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.room.MessageData#getDeprecatedName <em>Deprecated Name</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.room.MessageData#getRefType <em>Ref Type</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.etrice.core.room.RoomPackage#getMessageData()
+ * @model
+ * @generated
+ */
+public interface MessageData extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Deprecated Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Deprecated Name</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Deprecated Name</em>' attribute.
+   * @see #setDeprecatedName(String)
+   * @see org.eclipse.etrice.core.room.RoomPackage#getMessageData_DeprecatedName()
+   * @model
+   * @generated
+   */
+  String getDeprecatedName();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.etrice.core.room.MessageData#getDeprecatedName <em>Deprecated Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Deprecated Name</em>' attribute.
+   * @see #getDeprecatedName()
+   * @generated
+   */
+  void setDeprecatedName(String value);
+
+  /**
+   * Returns the value of the '<em><b>Ref Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Ref Type</em>' containment reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Ref Type</em>' containment reference.
+   * @see #setRefType(RefableType)
+   * @see org.eclipse.etrice.core.room.RoomPackage#getMessageData_RefType()
+   * @model containment="true"
+   * @generated
+   */
+  RefableType getRefType();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.etrice.core.room.MessageData#getRefType <em>Ref Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Ref Type</em>' containment reference.
+   * @see #getRefType()
+   * @generated
+   */
+  void setRefType(RefableType value);
+
+} // MessageData
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Port.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Port.java
index d93781ebb..70c230f2f 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Port.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/Port.java
@@ -182,7 +182,7 @@ public interface Port extends InterfaceItem
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @model kind="operation"
-   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return multiplicity>1 || multiplicity==-1;'"
+   *        annotation="http://www.eclipse.org/emf/2002/GenModel body='return multiplicity&gt;1 || multiplicity==-1;'"
    * @generated
    */
   boolean isReplicated();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RefSegment.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RefSegment.java
index fa7c5649a..8181e26de 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RefSegment.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RefSegment.java
@@ -86,7 +86,7 @@ public interface RefSegment extends EObject
   /**
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
-   * @model annotation="http://www.eclipse.org/emf/2002/GenModel body='return getRef() + ((getIdx()>=0)? \":\"+getIdx() : \"\");\r\n'"
+   * @model annotation="http://www.eclipse.org/emf/2002/GenModel body='return getRef() + ((getIdx()&gt;=0)? \":\"+getIdx() : \"\");\r\n'"
    * @generated
    */
   String toString();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomFactory.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomFactory.java
index a43c353e5..8ee26ff00 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomFactory.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomFactory.java
@@ -68,6 +68,15 @@ public interface RoomFactory extends EFactory
   VarDecl createVarDecl();
 
   /**
+   * Returns a new object of class '<em>Message Data</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Message Data</em>'.
+   * @generated
+   */
+  MessageData createMessageData();
+
+  /**
    * Returns a new object of class '<em>Refable Type</em>'.
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomPackage.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomPackage.java
index b6b5bbc6d..a16dbfa49 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomPackage.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/RoomPackage.java
@@ -434,6 +434,43 @@ public interface RoomPackage extends EPackage
   int VAR_DECL_FEATURE_COUNT = 2;
 
   /**
+   * The meta object id for the '{@link org.eclipse.etrice.core.room.impl.MessageDataImpl <em>Message Data</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.etrice.core.room.impl.MessageDataImpl
+   * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getMessageData()
+   * @generated
+   */
+  int MESSAGE_DATA = 5;
+
+  /**
+   * The feature id for the '<em><b>Deprecated Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MESSAGE_DATA__DEPRECATED_NAME = 0;
+
+  /**
+   * The feature id for the '<em><b>Ref Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MESSAGE_DATA__REF_TYPE = 1;
+
+  /**
+   * The number of structural features of the '<em>Message Data</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MESSAGE_DATA_FEATURE_COUNT = 2;
+
+  /**
    * The meta object id for the '{@link org.eclipse.etrice.core.room.impl.RefableTypeImpl <em>Refable Type</em>}' class.
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
@@ -441,7 +478,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRefableType()
    * @generated
    */
-  int REFABLE_TYPE = 5;
+  int REFABLE_TYPE = 6;
 
   /**
    * The feature id for the '<em><b>Type</b></em>' reference.
@@ -478,7 +515,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getDataType()
    * @generated
    */
-  int DATA_TYPE = 6;
+  int DATA_TYPE = 7;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -515,7 +552,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getComplexType()
    * @generated
    */
-  int COMPLEX_TYPE = 7;
+  int COMPLEX_TYPE = 8;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -552,7 +589,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getPrimitiveType()
    * @generated
    */
-  int PRIMITIVE_TYPE = 8;
+  int PRIMITIVE_TYPE = 9;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -625,7 +662,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getEnumerationType()
    * @generated
    */
-  int ENUMERATION_TYPE = 9;
+  int ENUMERATION_TYPE = 10;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -680,7 +717,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getEnumLiteral()
    * @generated
    */
-  int ENUM_LITERAL = 10;
+  int ENUM_LITERAL = 11;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -717,7 +754,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getExternalType()
    * @generated
    */
-  int EXTERNAL_TYPE = 11;
+  int EXTERNAL_TYPE = 12;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -772,7 +809,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getDataClass()
    * @generated
    */
-  int DATA_CLASS = 12;
+  int DATA_CLASS = 13;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -881,7 +918,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getAttribute()
    * @generated
    */
-  int ATTRIBUTE = 13;
+  int ATTRIBUTE = 14;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -945,7 +982,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getOperation()
    * @generated
    */
-  int OPERATION = 14;
+  int OPERATION = 15;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1009,7 +1046,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getStandardOperation()
    * @generated
    */
-  int STANDARD_OPERATION = 15;
+  int STANDARD_OPERATION = 16;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1082,7 +1119,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getPortOperation()
    * @generated
    */
-  int PORT_OPERATION = 16;
+  int PORT_OPERATION = 17;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1155,7 +1192,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getClassStructor()
    * @generated
    */
-  int CLASS_STRUCTOR = 17;
+  int CLASS_STRUCTOR = 18;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1192,7 +1229,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getGeneralProtocolClass()
    * @generated
    */
-  int GENERAL_PROTOCOL_CLASS = 18;
+  int GENERAL_PROTOCOL_CLASS = 19;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1238,7 +1275,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getProtocolClass()
    * @generated
    */
-  int PROTOCOL_CLASS = 19;
+  int PROTOCOL_CLASS = 20;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1374,7 +1411,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getCompoundProtocolClass()
    * @generated
    */
-  int COMPOUND_PROTOCOL_CLASS = 20;
+  int COMPOUND_PROTOCOL_CLASS = 21;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1429,7 +1466,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSubProtocol()
    * @generated
    */
-  int SUB_PROTOCOL = 21;
+  int SUB_PROTOCOL = 22;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1466,7 +1503,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getMessage()
    * @generated
    */
-  int MESSAGE = 22;
+  int MESSAGE = 23;
 
   /**
    * The feature id for the '<em><b>Priv</b></em>' attribute.
@@ -1530,7 +1567,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getPortClass()
    * @generated
    */
-  int PORT_CLASS = 23;
+  int PORT_CLASS = 24;
 
   /**
    * The feature id for the '<em><b>User Code</b></em>' containment reference.
@@ -1585,7 +1622,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getMessageHandler()
    * @generated
    */
-  int MESSAGE_HANDLER = 24;
+  int MESSAGE_HANDLER = 25;
 
   /**
    * The feature id for the '<em><b>Msg</b></em>' reference.
@@ -1622,7 +1659,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getInMessageHandler()
    * @generated
    */
-  int IN_MESSAGE_HANDLER = 25;
+  int IN_MESSAGE_HANDLER = 26;
 
   /**
    * The feature id for the '<em><b>Msg</b></em>' reference.
@@ -1659,7 +1696,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getOutMessageHandler()
    * @generated
    */
-  int OUT_MESSAGE_HANDLER = 26;
+  int OUT_MESSAGE_HANDLER = 27;
 
   /**
    * The feature id for the '<em><b>Msg</b></em>' reference.
@@ -1696,7 +1733,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getActorClass()
    * @generated
    */
-  int ACTOR_CLASS = 27;
+  int ACTOR_CLASS = 28;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1949,7 +1986,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getInterfaceItem()
    * @generated
    */
-  int INTERFACE_ITEM = 28;
+  int INTERFACE_ITEM = 29;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -1977,7 +2014,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getPort()
    * @generated
    */
-  int PORT = 29;
+  int PORT = 30;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2050,7 +2087,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getExternalPort()
    * @generated
    */
-  int EXTERNAL_PORT = 30;
+  int EXTERNAL_PORT = 31;
 
   /**
    * The feature id for the '<em><b>Interface Port</b></em>' reference.
@@ -2078,7 +2115,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSAP()
    * @generated
    */
-  int SAP = 31;
+  int SAP = 32;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2115,7 +2152,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSPP()
    * @generated
    */
-  int SPP = 32;
+  int SPP = 33;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2152,7 +2189,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getServiceImplementation()
    * @generated
    */
-  int SERVICE_IMPLEMENTATION = 33;
+  int SERVICE_IMPLEMENTATION = 34;
 
   /**
    * The feature id for the '<em><b>Spp</b></em>' reference.
@@ -2180,7 +2217,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getLogicalSystem()
    * @generated
    */
-  int LOGICAL_SYSTEM = 34;
+  int LOGICAL_SYSTEM = 35;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2253,7 +2290,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getActorContainerRef()
    * @generated
    */
-  int ACTOR_CONTAINER_REF = 35;
+  int ACTOR_CONTAINER_REF = 36;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2290,7 +2327,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSubSystemRef()
    * @generated
    */
-  int SUB_SYSTEM_REF = 36;
+  int SUB_SYSTEM_REF = 37;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2336,7 +2373,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSubSystemClass()
    * @generated
    */
-  int SUB_SYSTEM_CLASS = 37;
+  int SUB_SYSTEM_CLASS = 38;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2472,7 +2509,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getLogicalThread()
    * @generated
    */
-  int LOGICAL_THREAD = 38;
+  int LOGICAL_THREAD = 39;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2500,7 +2537,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getActorInstanceMapping()
    * @generated
    */
-  int ACTOR_INSTANCE_MAPPING = 39;
+  int ACTOR_INSTANCE_MAPPING = 40;
 
   /**
    * The feature id for the '<em><b>Path</b></em>' containment reference.
@@ -2546,7 +2583,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRefPath()
    * @generated
    */
-  int REF_PATH = 40;
+  int REF_PATH = 41;
 
   /**
    * The feature id for the '<em><b>Refs</b></em>' containment reference list.
@@ -2574,7 +2611,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRefSegment()
    * @generated
    */
-  int REF_SEGMENT = 41;
+  int REF_SEGMENT = 42;
 
   /**
    * The feature id for the '<em><b>Ref</b></em>' attribute.
@@ -2611,7 +2648,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getBinding()
    * @generated
    */
-  int BINDING = 42;
+  int BINDING = 43;
 
   /**
    * The feature id for the '<em><b>Endpoint1</b></em>' containment reference.
@@ -2648,7 +2685,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getBindingEndPoint()
    * @generated
    */
-  int BINDING_END_POINT = 43;
+  int BINDING_END_POINT = 44;
 
   /**
    * The feature id for the '<em><b>Actor Ref</b></em>' reference.
@@ -2694,7 +2731,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getLayerConnection()
    * @generated
    */
-  int LAYER_CONNECTION = 44;
+  int LAYER_CONNECTION = 45;
 
   /**
    * The feature id for the '<em><b>From</b></em>' containment reference.
@@ -2731,7 +2768,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSAPoint()
    * @generated
    */
-  int SA_POINT = 45;
+  int SA_POINT = 46;
 
   /**
    * The number of structural features of the '<em>SA Point</em>' class.
@@ -2750,7 +2787,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRefSAPoint()
    * @generated
    */
-  int REF_SA_POINT = 46;
+  int REF_SA_POINT = 47;
 
   /**
    * The feature id for the '<em><b>Ref</b></em>' reference.
@@ -2778,7 +2815,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRelaySAPoint()
    * @generated
    */
-  int RELAY_SA_POINT = 47;
+  int RELAY_SA_POINT = 48;
 
   /**
    * The feature id for the '<em><b>Relay</b></em>' reference.
@@ -2806,7 +2843,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getSPPoint()
    * @generated
    */
-  int SP_POINT = 48;
+  int SP_POINT = 49;
 
   /**
    * The feature id for the '<em><b>Ref</b></em>' reference.
@@ -2843,7 +2880,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getActorRef()
    * @generated
    */
-  int ACTOR_REF = 49;
+  int ACTOR_REF = 50;
 
   /**
    * The feature id for the '<em><b>Name</b></em>' attribute.
@@ -2907,7 +2944,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getCommunicationType()
    * @generated
    */
-  int COMMUNICATION_TYPE = 50;
+  int COMMUNICATION_TYPE = 51;
 
   /**
    * The meta object id for the '{@link org.eclipse.etrice.core.room.ReferenceType <em>Reference Type</em>}' enum.
@@ -2917,7 +2954,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getReferenceType()
    * @generated
    */
-  int REFERENCE_TYPE = 51;
+  int REFERENCE_TYPE = 52;
 
   /**
    * The meta object id for the '{@link org.eclipse.etrice.core.room.RoomAnnotationTargetEnum <em>Annotation Target Enum</em>}' enum.
@@ -2927,7 +2964,7 @@ public interface RoomPackage extends EPackage
    * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getRoomAnnotationTargetEnum()
    * @generated
    */
-  int ROOM_ANNOTATION_TARGET_ENUM = 52;
+  int ROOM_ANNOTATION_TARGET_ENUM = 53;
 
 
   /**
@@ -3245,6 +3282,38 @@ public interface RoomPackage extends EPackage
   EReference getVarDecl_RefType();
 
   /**
+   * Returns the meta object for class '{@link org.eclipse.etrice.core.room.MessageData <em>Message Data</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Message Data</em>'.
+   * @see org.eclipse.etrice.core.room.MessageData
+   * @generated
+   */
+  EClass getMessageData();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.etrice.core.room.MessageData#getDeprecatedName <em>Deprecated Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Deprecated Name</em>'.
+   * @see org.eclipse.etrice.core.room.MessageData#getDeprecatedName()
+   * @see #getMessageData()
+   * @generated
+   */
+  EAttribute getMessageData_DeprecatedName();
+
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.etrice.core.room.MessageData#getRefType <em>Ref Type</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Ref Type</em>'.
+   * @see org.eclipse.etrice.core.room.MessageData#getRefType()
+   * @see #getMessageData()
+   * @generated
+   */
+  EReference getMessageData_RefType();
+
+  /**
    * Returns the meta object for class '{@link org.eclipse.etrice.core.room.RefableType <em>Refable Type</em>}'.
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
@@ -5167,6 +5236,32 @@ public interface RoomPackage extends EPackage
     EReference VAR_DECL__REF_TYPE = eINSTANCE.getVarDecl_RefType();
 
     /**
+     * The meta object literal for the '{@link org.eclipse.etrice.core.room.impl.MessageDataImpl <em>Message Data</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.etrice.core.room.impl.MessageDataImpl
+     * @see org.eclipse.etrice.core.room.impl.RoomPackageImpl#getMessageData()
+     * @generated
+     */
+    EClass MESSAGE_DATA = eINSTANCE.getMessageData();
+
+    /**
+     * The meta object literal for the '<em><b>Deprecated Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute MESSAGE_DATA__DEPRECATED_NAME = eINSTANCE.getMessageData_DeprecatedName();
+
+    /**
+     * The meta object literal for the '<em><b>Ref Type</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference MESSAGE_DATA__REF_TYPE = eINSTANCE.getMessageData_RefType();
+
+    /**
      * The meta object literal for the '{@link org.eclipse.etrice.core.room.impl.RefableTypeImpl <em>Refable Type</em>}' class.
      * <!-- begin-user-doc -->
      * <!-- end-user-doc -->
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/ActorClassImpl.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/ActorClassImpl.java
index 3655f6e95..54eddbcfb 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/ActorClassImpl.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/ActorClassImpl.java
@@ -673,7 +673,8 @@ public class ActorClassImpl extends ActorContainerClassImpl implements ActorClas
   {
     EList<Port> ports = new BasicEList<Port>();
     for (ExternalPort ep : getExternalPorts()) {
-      ports.add(ep.getInterfacePort());
+      if(ep.getInterfacePort() != null)
+        ports.add(ep.getInterfacePort());
     }
     return ports;
     
@@ -688,7 +689,8 @@ public class ActorClassImpl extends ActorContainerClassImpl implements ActorClas
   {
     EList<Port> ports = new BasicEList<Port>(getInterfacePorts());
     for (ExternalPort ep : getExternalPorts()) {
-      ports.remove(ep.getInterfacePort());
+      if(ep.getInterfacePort() != null)
+        ports.remove(ep.getInterfacePort());
     }
     return ports;
     
@@ -703,7 +705,8 @@ public class ActorClassImpl extends ActorContainerClassImpl implements ActorClas
   {
     EList<SPP> spps = new BasicEList<SPP>();
     for (ServiceImplementation spp : getServiceImplementations()) {
-      spps.add(spp.getSpp());
+      if(spp.getSpp() != null)
+        spps.add(spp.getSpp());
     }
     return spps;
     
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageDataImpl.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageDataImpl.java
new file mode 100644
index 000000000..10164fc7b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageDataImpl.java
@@ -0,0 +1,265 @@
+/**
+ */
+package org.eclipse.etrice.core.room.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.etrice.core.room.MessageData;
+import org.eclipse.etrice.core.room.RefableType;
+import org.eclipse.etrice.core.room.RoomPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Message Data</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.etrice.core.room.impl.MessageDataImpl#getDeprecatedName <em>Deprecated Name</em>}</li>
+ *   <li>{@link org.eclipse.etrice.core.room.impl.MessageDataImpl#getRefType <em>Ref Type</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class MessageDataImpl extends MinimalEObjectImpl.Container implements MessageData
+{
+  /**
+   * The default value of the '{@link #getDeprecatedName() <em>Deprecated Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getDeprecatedName()
+   * @generated
+   * @ordered
+   */
+  protected static final String DEPRECATED_NAME_EDEFAULT = null;
+
+  /**
+   * The cached value of the '{@link #getDeprecatedName() <em>Deprecated Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getDeprecatedName()
+   * @generated
+   * @ordered
+   */
+  protected String deprecatedName = DEPRECATED_NAME_EDEFAULT;
+
+  /**
+   * The cached value of the '{@link #getRefType() <em>Ref Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getRefType()
+   * @generated
+   * @ordered
+   */
+  protected RefableType refType;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected MessageDataImpl()
+  {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return RoomPackage.Literals.MESSAGE_DATA;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public String getDeprecatedName()
+  {
+    return deprecatedName;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setDeprecatedName(String newDeprecatedName)
+  {
+    String oldDeprecatedName = deprecatedName;
+    deprecatedName = newDeprecatedName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, RoomPackage.MESSAGE_DATA__DEPRECATED_NAME, oldDeprecatedName, deprecatedName));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public RefableType getRefType()
+  {
+    return refType;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetRefType(RefableType newRefType, NotificationChain msgs)
+  {
+    RefableType oldRefType = refType;
+    refType = newRefType;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RoomPackage.MESSAGE_DATA__REF_TYPE, oldRefType, newRefType);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setRefType(RefableType newRefType)
+  {
+    if (newRefType != refType)
+    {
+      NotificationChain msgs = null;
+      if (refType != null)
+        msgs = ((InternalEObject)refType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - RoomPackage.MESSAGE_DATA__REF_TYPE, null, msgs);
+      if (newRefType != null)
+        msgs = ((InternalEObject)newRefType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - RoomPackage.MESSAGE_DATA__REF_TYPE, null, msgs);
+      msgs = basicSetRefType(newRefType, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, RoomPackage.MESSAGE_DATA__REF_TYPE, newRefType, newRefType));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case RoomPackage.MESSAGE_DATA__REF_TYPE:
+        return basicSetRefType(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case RoomPackage.MESSAGE_DATA__DEPRECATED_NAME:
+        return getDeprecatedName();
+      case RoomPackage.MESSAGE_DATA__REF_TYPE:
+        return getRefType();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case RoomPackage.MESSAGE_DATA__DEPRECATED_NAME:
+        setDeprecatedName((String)newValue);
+        return;
+      case RoomPackage.MESSAGE_DATA__REF_TYPE:
+        setRefType((RefableType)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case RoomPackage.MESSAGE_DATA__DEPRECATED_NAME:
+        setDeprecatedName(DEPRECATED_NAME_EDEFAULT);
+        return;
+      case RoomPackage.MESSAGE_DATA__REF_TYPE:
+        setRefType((RefableType)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case RoomPackage.MESSAGE_DATA__DEPRECATED_NAME:
+        return DEPRECATED_NAME_EDEFAULT == null ? deprecatedName != null : !DEPRECATED_NAME_EDEFAULT.equals(deprecatedName);
+      case RoomPackage.MESSAGE_DATA__REF_TYPE:
+        return refType != null;
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+
+    StringBuffer result = new StringBuffer(super.toString());
+    result.append(" (deprecatedName: ");
+    result.append(deprecatedName);
+    result.append(')');
+    return result.toString();
+  }
+
+} //MessageDataImpl
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageImpl.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageImpl.java
index 3937db174..b6def512a 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageImpl.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/MessageImpl.java
@@ -22,8 +22,8 @@ import org.eclipse.etrice.core.common.base.Annotation;
 import org.eclipse.etrice.core.common.base.Documentation;
 
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.RoomPackage;
-import org.eclipse.etrice.core.room.VarDecl;
 
 /**
  * <!-- begin-user-doc -->
@@ -92,7 +92,7 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
    * @generated
    * @ordered
    */
-  protected VarDecl data;
+  protected MessageData data;
 
   /**
    * The cached value of the '{@link #getAnnotations() <em>Annotations</em>}' containment reference list.
@@ -186,7 +186,7 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
    * <!-- end-user-doc -->
    * @generated
    */
-  public VarDecl getData()
+  public MessageData getData()
   {
     return data;
   }
@@ -196,9 +196,9 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
    * <!-- end-user-doc -->
    * @generated
    */
-  public NotificationChain basicSetData(VarDecl newData, NotificationChain msgs)
+  public NotificationChain basicSetData(MessageData newData, NotificationChain msgs)
   {
-    VarDecl oldData = data;
+    MessageData oldData = data;
     data = newData;
     if (eNotificationRequired())
     {
@@ -213,7 +213,7 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
    * <!-- end-user-doc -->
    * @generated
    */
-  public void setData(VarDecl newData)
+  public void setData(MessageData newData)
   {
     if (newData != data)
     {
@@ -353,7 +353,7 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
         setName((String)newValue);
         return;
       case RoomPackage.MESSAGE__DATA:
-        setData((VarDecl)newValue);
+        setData((MessageData)newValue);
         return;
       case RoomPackage.MESSAGE__ANNOTATIONS:
         getAnnotations().clear();
@@ -383,7 +383,7 @@ public class MessageImpl extends MinimalEObjectImpl.Container implements Message
         setName(NAME_EDEFAULT);
         return;
       case RoomPackage.MESSAGE__DATA:
-        setData((VarDecl)null);
+        setData((MessageData)null);
         return;
       case RoomPackage.MESSAGE__ANNOTATIONS:
         getAnnotations().clear();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomFactoryImpl.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomFactoryImpl.java
index f5279edc8..38ae4f3f9 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomFactoryImpl.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomFactoryImpl.java
@@ -70,6 +70,7 @@ public class RoomFactoryImpl extends EFactoryImpl implements RoomFactory
       case RoomPackage.STRUCTURE_CLASS: return createStructureClass();
       case RoomPackage.ACTOR_CONTAINER_CLASS: return createActorContainerClass();
       case RoomPackage.VAR_DECL: return createVarDecl();
+      case RoomPackage.MESSAGE_DATA: return createMessageData();
       case RoomPackage.REFABLE_TYPE: return createRefableType();
       case RoomPackage.DATA_TYPE: return createDataType();
       case RoomPackage.COMPLEX_TYPE: return createComplexType();
@@ -222,6 +223,17 @@ public class RoomFactoryImpl extends EFactoryImpl implements RoomFactory
    * <!-- end-user-doc -->
    * @generated
    */
+  public MessageData createMessageData()
+  {
+    MessageDataImpl messageData = new MessageDataImpl();
+    return messageData;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
   public RefableType createRefableType()
   {
     RefableTypeImpl refableType = new RefableTypeImpl();
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomPackageImpl.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomPackageImpl.java
index 7a0c0aaa9..9de5562cb 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomPackageImpl.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/impl/RoomPackageImpl.java
@@ -39,6 +39,7 @@ import org.eclipse.etrice.core.room.LayerConnection;
 import org.eclipse.etrice.core.room.LogicalSystem;
 import org.eclipse.etrice.core.room.LogicalThread;
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.MessageHandler;
 import org.eclipse.etrice.core.room.Operation;
 import org.eclipse.etrice.core.room.OutMessageHandler;
@@ -116,6 +117,13 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
    * <!-- end-user-doc -->
    * @generated
    */
+  private EClass messageDataEClass = null;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
   private EClass refableTypeEClass = null;
 
   /**
@@ -496,6 +504,7 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
     isInited = true;
 
     // Initialize simple dependencies
+    BasePackage.eINSTANCE.eClass();
     FSMPackage.eINSTANCE.eClass();
 
     // Create package meta-data objects
@@ -808,6 +817,36 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
    * <!-- end-user-doc -->
    * @generated
    */
+  public EClass getMessageData()
+  {
+    return messageDataEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EAttribute getMessageData_DeprecatedName()
+  {
+    return (EAttribute)messageDataEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EReference getMessageData_RefType()
+  {
+    return (EReference)messageDataEClass.getEStructuralFeatures().get(1);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
   public EClass getRefableType()
   {
     return refableTypeEClass;
@@ -2417,6 +2456,10 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
     createEAttribute(varDeclEClass, VAR_DECL__NAME);
     createEReference(varDeclEClass, VAR_DECL__REF_TYPE);
 
+    messageDataEClass = createEClass(MESSAGE_DATA);
+    createEAttribute(messageDataEClass, MESSAGE_DATA__DEPRECATED_NAME);
+    createEReference(messageDataEClass, MESSAGE_DATA__REF_TYPE);
+
     refableTypeEClass = createEClass(REFABLE_TYPE);
     createEReference(refableTypeEClass, REFABLE_TYPE__TYPE);
     createEAttribute(refableTypeEClass, REFABLE_TYPE__REF);
@@ -2716,6 +2759,10 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
     initEAttribute(getVarDecl_Name(), ecorePackage.getEString(), "name", null, 0, 1, VarDecl.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
     initEReference(getVarDecl_RefType(), this.getRefableType(), null, "refType", null, 0, 1, VarDecl.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
+    initEClass(messageDataEClass, MessageData.class, "MessageData", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getMessageData_DeprecatedName(), ecorePackage.getEString(), "deprecatedName", null, 0, 1, MessageData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getMessageData_RefType(), this.getRefableType(), null, "refType", null, 0, 1, MessageData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
     initEClass(refableTypeEClass, RefableType.class, "RefableType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
     initEReference(getRefableType_Type(), this.getDataType(), null, "type", null, 0, 1, RefableType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
     initEAttribute(getRefableType_Ref(), ecorePackage.getEBoolean(), "ref", null, 0, 1, RefableType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
@@ -2807,7 +2854,7 @@ public class RoomPackageImpl extends EPackageImpl implements RoomPackage
     initEClass(messageEClass, Message.class, "Message", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
     initEAttribute(getMessage_Priv(), ecorePackage.getEBoolean(), "priv", null, 0, 1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
     initEAttribute(getMessage_Name(), ecorePackage.getEString(), "name", null, 0, 1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-    initEReference(getMessage_Data(), this.getVarDecl(), null, "data", null, 0, 1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getMessage_Data(), this.getMessageData(), null, "data", null, 0, 1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
     initEReference(getMessage_Annotations(), theBasePackage.getAnnotation(), null, "annotations", null, 0, -1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
     initEReference(getMessage_Docu(), theBasePackage.getDocumentation(), null, "docu", null, 0, 1, Message.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomAdapterFactory.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomAdapterFactory.java
index d4ec8cefb..99460678c 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomAdapterFactory.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomAdapterFactory.java
@@ -104,6 +104,11 @@ public class RoomAdapterFactory extends AdapterFactoryImpl
         return createVarDeclAdapter();
       }
       @Override
+      public Adapter caseMessageData(MessageData object)
+      {
+        return createMessageDataAdapter();
+      }
+      @Override
       public Adapter caseRefableType(RefableType object)
       {
         return createRefableTypeAdapter();
@@ -441,6 +446,21 @@ public class RoomAdapterFactory extends AdapterFactoryImpl
   }
 
   /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.room.MessageData <em>Message Data</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.etrice.core.room.MessageData
+   * @generated
+   */
+  public Adapter createMessageDataAdapter()
+  {
+    return null;
+  }
+
+  /**
    * Creates a new adapter for an object of class '{@link org.eclipse.etrice.core.room.RefableType <em>Refable Type</em>}'.
    * <!-- begin-user-doc -->
    * This default implementation returns null so that we can easily ignore cases;
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomSwitch.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomSwitch.java
index 9b7472ba4..c51998737 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomSwitch.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/room/util/RoomSwitch.java
@@ -114,6 +114,13 @@ public class RoomSwitch<T> extends Switch<T>
         if (result == null) result = defaultCase(theEObject);
         return result;
       }
+      case RoomPackage.MESSAGE_DATA:
+      {
+        MessageData messageData = (MessageData)theEObject;
+        T result = caseMessageData(messageData);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
       case RoomPackage.REFABLE_TYPE:
       {
         RefableType refableType = (RefableType)theEObject;
@@ -557,6 +564,22 @@ public class RoomSwitch<T> extends Switch<T>
   }
 
   /**
+   * Returns the result of interpreting the object as an instance of '<em>Message Data</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Message Data</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseMessageData(MessageData object)
+  {
+    return null;
+  }
+
+  /**
    * Returns the result of interpreting the object as an instance of '<em>Refable Type</em>'.
    * <!-- begin-user-doc -->
    * This implementation returns null;
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSemanticSequencer.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSemanticSequencer.java
index c34402124..8a4c6b6f0 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSemanticSequencer.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSemanticSequencer.java
@@ -65,6 +65,7 @@ import org.eclipse.etrice.core.room.LayerConnection;
 import org.eclipse.etrice.core.room.LogicalSystem;
 import org.eclipse.etrice.core.room.LogicalThread;
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.OutMessageHandler;
 import org.eclipse.etrice.core.room.Port;
 import org.eclipse.etrice.core.room.PortClass;
@@ -287,6 +288,9 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 			case RoomPackage.MESSAGE:
 				sequence_Message(context, (Message) semanticObject); 
 				return; 
+			case RoomPackage.MESSAGE_DATA:
+				sequence_MessageData(context, (MessageData) semanticObject); 
+				return; 
 			case RoomPackage.OUT_MESSAGE_HANDLER:
 				sequence_OutMessageHandler(context, (OutMessageHandler) semanticObject); 
 				return; 
@@ -370,24 +374,24 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 	 *         docu=Documentation? 
 	 *         base=[ActorClass|FQN]? 
 	 *         annotations+=Annotation* 
-	 *         interfacePorts+=Port? 
-	 *         (serviceProvisionPoints+=SPP? interfacePorts+=Port?)* 
+	 *         serviceProvisionPoints+=SPP? 
+	 *         (interfacePorts+=Port? serviceProvisionPoints+=SPP?)* 
 	 *         structureDocu=Documentation? 
 	 *         userCode1=DetailCode? 
 	 *         userCode2=DetailCode? 
 	 *         userCode3=DetailCode? 
-	 *         attributes+=Attribute? 
+	 *         serviceImplementations+=ServiceImplementation? 
 	 *         (
 	 *             (
 	 *                 connections+=LayerConnection | 
 	 *                 bindings+=Binding | 
-	 *                 serviceImplementations+=ServiceImplementation | 
+	 *                 attributes+=Attribute | 
 	 *                 actorRefs+=ActorRef | 
 	 *                 serviceAccessPoints+=SAP | 
 	 *                 internalPorts+=Port | 
 	 *                 externalPorts+=ExternalPort
 	 *             )? 
-	 *             attributes+=Attribute?
+	 *             serviceImplementations+=ServiceImplementation?
 	 *         )* 
 	 *         behaviorDocu=Documentation? 
 	 *         behaviorAnnotations+=Annotation* 
@@ -656,10 +660,22 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 	
 	/**
 	 * Contexts:
+	 *     MessageData returns MessageData
+	 *
+	 * Constraint:
+	 *     (deprecatedName=ID? refType=RefableType)
+	 */
+	protected void sequence_MessageData(ISerializationContext context, MessageData semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * Contexts:
 	 *     Message returns Message
 	 *
 	 * Constraint:
-	 *     (priv?='private'? name=ID data=VarDecl? annotations+=Annotation* docu=Documentation?)
+	 *     (priv?='private'? name=ID data=MessageData? annotations+=Annotation* docu=Documentation?)
 	 */
 	protected void sequence_Message(ISerializationContext context, Message semanticObject) {
 		genericSequencer.createSequence(context, semanticObject);
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSyntacticSequencer.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSyntacticSequencer.java
index 7a93af314..236ffadde 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSyntacticSequencer.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/serializer/RoomSyntacticSequencer.java
@@ -27,6 +27,7 @@ public class RoomSyntacticSequencer extends AbstractSyntacticSequencer {
 	protected AbstractElementAlias match_ActorInstanceMapping___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q;
 	protected AbstractElementAlias match_ContinuationTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q;
 	protected AbstractElementAlias match_InitialTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q;
+	protected AbstractElementAlias match_Message___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q;
 	protected AbstractElementAlias match_PortOperation___ColonKeyword_5_0_0_VoidKeyword_5_0_1_0__q;
 	protected AbstractElementAlias match_ProtocolClass___IncomingKeyword_10_0_LeftCurlyBracketKeyword_10_1_RightCurlyBracketKeyword_10_3__q;
 	protected AbstractElementAlias match_ProtocolClass___OutgoingKeyword_11_0_LeftCurlyBracketKeyword_11_1_RightCurlyBracketKeyword_11_3__q;
@@ -42,6 +43,7 @@ public class RoomSyntacticSequencer extends AbstractSyntacticSequencer {
 		match_ActorInstanceMapping___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0()), new TokenAlias(false, false, grammarAccess.getActorInstanceMappingAccess().getRightCurlyBracketKeyword_4_2()));
 		match_ContinuationTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()), new TokenAlias(false, false, grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()));
 		match_InitialTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()), new TokenAlias(false, false, grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()));
+		match_Message___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3_0()), new TokenAlias(false, false, grammarAccess.getMessageAccess().getRightParenthesisKeyword_3_2()));
 		match_PortOperation___ColonKeyword_5_0_0_VoidKeyword_5_0_1_0__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0()), new TokenAlias(false, false, grammarAccess.getPortOperationAccess().getVoidKeyword_5_0_1_0()));
 		match_ProtocolClass___IncomingKeyword_10_0_LeftCurlyBracketKeyword_10_1_RightCurlyBracketKeyword_10_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getIncomingKeyword_10_0()), new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1()), new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_10_3()));
 		match_ProtocolClass___OutgoingKeyword_11_0_LeftCurlyBracketKeyword_11_1_RightCurlyBracketKeyword_11_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getOutgoingKeyword_11_0()), new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1()), new TokenAlias(false, false, grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_11_3()));
@@ -73,6 +75,8 @@ public class RoomSyntacticSequencer extends AbstractSyntacticSequencer {
 				emit_ContinuationTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
 			else if (match_InitialTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q.equals(syntax))
 				emit_InitialTransition___LeftCurlyBracketKeyword_7_0_RightCurlyBracketKeyword_7_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_Message___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q.equals(syntax))
+				emit_Message___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
 			else if (match_PortOperation___ColonKeyword_5_0_0_VoidKeyword_5_0_1_0__q.equals(syntax))
 				emit_PortOperation___ColonKeyword_5_0_0_VoidKeyword_5_0_1_0__q(semanticObject, getLastNavigableState(), syntaxNodes);
 			else if (match_ProtocolClass___IncomingKeyword_10_0_LeftCurlyBracketKeyword_10_1_RightCurlyBracketKeyword_10_3__q.equals(syntax))
@@ -280,6 +284,19 @@ public class RoomSyntacticSequencer extends AbstractSyntacticSequencer {
 	
 	/**
 	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     name=ID (ambiguity) (rule end)
+	 *     name=ID (ambiguity) annotations+=Annotation
+	 *     name=ID (ambiguity) docu=Documentation
+	 */
+	protected void emit_Message___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
 	 *     (':' 'void')?
 	 *
 	 * This ambiguous syntax occurs at:
diff --git a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/services/RoomGrammarAccess.java b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/services/RoomGrammarAccess.java
index d8517a5ca..16f33814d 100644
--- a/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/services/RoomGrammarAccess.java
+++ b/plugins/org.eclipse.etrice.core.room/src-gen/org/eclipse/etrice/core/services/RoomGrammarAccess.java
@@ -210,10 +210,10 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//ActorClass | SubSystemClass
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ActorClass'
+		//ActorClass
 		public RuleCall getActorClassParserRuleCall_0() { return cActorClassParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.3/@alternatives/@elements.1'
+		//SubSystemClass
 		public RuleCall getSubSystemClassParserRuleCall_1() { return cSubSystemClassParserRuleCall_1; }
 	}
 
@@ -226,28 +226,67 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cRefTypeAssignment_2 = (Assignment)cGroup.eContents().get(2);
 		private final RuleCall cRefTypeRefableTypeParserRuleCall_2_0 = (RuleCall)cRefTypeAssignment_2.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/VarDecl'
+		//// **************************************************************
+		//// data class
+		//VarDecl:
+		//	name=ID ':' refType=RefableType;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives'
+		//name=ID ':' refType=RefableType
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives/@elements.0'
+		//name=ID
 		public Assignment getNameAssignment_0() { return cNameAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives/@elements.0/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_0_0() { return cNameIDTerminalRuleCall_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives/@elements.1'
+		//':'
 		public Keyword getColonKeyword_1() { return cColonKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives/@elements.2'
+		//refType=RefableType
 		public Assignment getRefTypeAssignment_2() { return cRefTypeAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.4/@alternatives/@elements.2/@terminal'
+		//RefableType
 		public RuleCall getRefTypeRefableTypeParserRuleCall_2_0() { return cRefTypeRefableTypeParserRuleCall_2_0; }
 	}
 
+	public class MessageDataElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.etrice.core.Room.MessageData");
+		private final Group cGroup = (Group)rule.eContents().get(1);
+		private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+		private final Assignment cDeprecatedNameAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
+		private final RuleCall cDeprecatedNameIDTerminalRuleCall_0_0_0 = (RuleCall)cDeprecatedNameAssignment_0_0.eContents().get(0);
+		private final Keyword cColonKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+		private final Assignment cRefTypeAssignment_1 = (Assignment)cGroup.eContents().get(1);
+		private final RuleCall cRefTypeRefableTypeParserRuleCall_1_0 = (RuleCall)cRefTypeAssignment_1.eContents().get(0);
+		
+		//MessageData:
+		//	(deprecatedName=ID ':')? refType=RefableType;
+		@Override public ParserRule getRule() { return rule; }
+
+		//(deprecatedName=ID ':')? refType=RefableType
+		public Group getGroup() { return cGroup; }
+
+		//(deprecatedName=ID ':')?
+		public Group getGroup_0() { return cGroup_0; }
+
+		//deprecatedName=ID
+		public Assignment getDeprecatedNameAssignment_0_0() { return cDeprecatedNameAssignment_0_0; }
+
+		//ID
+		public RuleCall getDeprecatedNameIDTerminalRuleCall_0_0_0() { return cDeprecatedNameIDTerminalRuleCall_0_0_0; }
+
+		//':'
+		public Keyword getColonKeyword_0_1() { return cColonKeyword_0_1; }
+
+		//refType=RefableType
+		public Assignment getRefTypeAssignment_1() { return cRefTypeAssignment_1; }
+
+		//RefableType
+		public RuleCall getRefTypeRefableTypeParserRuleCall_1_0() { return cRefTypeRefableTypeParserRuleCall_1_0; }
+	}
+
 	public class RefableTypeElements extends AbstractParserRuleElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.etrice.core.Room.RefableType");
 		private final Group cGroup = (Group)rule.eContents().get(1);
@@ -257,25 +296,26 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cRefAssignment_1 = (Assignment)cGroup.eContents().get(1);
 		private final Keyword cRefRefKeyword_1_0 = (Keyword)cRefAssignment_1.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/RefableType'
+		//RefableType:
+		//	type=[DataType|FQN] ref?='ref'?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives'
+		//type=[DataType|FQN] ref?='ref'?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives/@elements.0'
+		//type=[DataType|FQN]
 		public Assignment getTypeAssignment_0() { return cTypeAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives/@elements.0/@terminal'
+		//[DataType|FQN]
 		public CrossReference getTypeDataTypeCrossReference_0_0() { return cTypeDataTypeCrossReference_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives/@elements.0/@terminal/@terminal'
+		//FQN
 		public RuleCall getTypeDataTypeFQNParserRuleCall_0_0_1() { return cTypeDataTypeFQNParserRuleCall_0_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives/@elements.1'
+		//ref?='ref'?
 		public Assignment getRefAssignment_1() { return cRefAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.5/@alternatives/@elements.1/@terminal'
+		//'ref'
 		public Keyword getRefRefKeyword_1_0() { return cRefRefKeyword_1_0; }
 	}
 
@@ -286,19 +326,20 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cEnumerationTypeParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		private final RuleCall cComplexTypeParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/DataType'
+		//DataType:
+		//	PrimitiveType | EnumerationType | ComplexType;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.6/@alternatives'
+		//PrimitiveType | EnumerationType | ComplexType
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.6/@alternatives/@elements.0'
+		//PrimitiveType
 		public RuleCall getPrimitiveTypeParserRuleCall_0() { return cPrimitiveTypeParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.6/@alternatives/@elements.1'
+		//EnumerationType
 		public RuleCall getEnumerationTypeParserRuleCall_1() { return cEnumerationTypeParserRuleCall_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.6/@alternatives/@elements.2'
+		//ComplexType
 		public RuleCall getComplexTypeParserRuleCall_2() { return cComplexTypeParserRuleCall_2; }
 	}
 
@@ -308,16 +349,17 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cDataClassParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cExternalTypeParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ComplexType'
+		//ComplexType:
+		//	DataClass | ExternalType;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.7/@alternatives'
+		//DataClass | ExternalType
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.7/@alternatives/@elements.0'
+		//DataClass
 		public RuleCall getDataClassParserRuleCall_0() { return cDataClassParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.7/@alternatives/@elements.1'
+		//ExternalType
 		public RuleCall getExternalTypeParserRuleCall_1() { return cExternalTypeParserRuleCall_1; }
 	}
 
@@ -344,67 +386,70 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDocuAssignment_9 = (Assignment)cGroup.eContents().get(9);
 		private final RuleCall cDocuDocumentationParserRuleCall_9_0 = (RuleCall)cDocuAssignment_9.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/PrimitiveType'
+		//PrimitiveType:
+		//	'PrimitiveType' name=ID ':' type=LiteralType '->' targetName=STRING ('(' castName=FQN ')')? 'default'
+		//	defaultValueLiteral=STRING docu=Documentation?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives'
+		//'PrimitiveType' name=ID ':' type=LiteralType '->' targetName=STRING ('(' castName=FQN ')')? 'default'
+		//defaultValueLiteral=STRING docu=Documentation?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.0'
+		//'PrimitiveType'
 		public Keyword getPrimitiveTypeKeyword_0() { return cPrimitiveTypeKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.2'
+		//':'
 		public Keyword getColonKeyword_2() { return cColonKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.3'
+		//type=LiteralType
 		public Assignment getTypeAssignment_3() { return cTypeAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.3/@terminal'
+		//LiteralType
 		public RuleCall getTypeLiteralTypeEnumRuleCall_3_0() { return cTypeLiteralTypeEnumRuleCall_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.4'
+		//'->'
 		public Keyword getHyphenMinusGreaterThanSignKeyword_4() { return cHyphenMinusGreaterThanSignKeyword_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.5'
+		//targetName=STRING
 		public Assignment getTargetNameAssignment_5() { return cTargetNameAssignment_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.5/@terminal'
+		//STRING
 		public RuleCall getTargetNameSTRINGTerminalRuleCall_5_0() { return cTargetNameSTRINGTerminalRuleCall_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.6'
+		//('(' castName=FQN ')')?
 		public Group getGroup_6() { return cGroup_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.6/@elements.0'
+		//'('
 		public Keyword getLeftParenthesisKeyword_6_0() { return cLeftParenthesisKeyword_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.6/@elements.1'
+		//castName=FQN
 		public Assignment getCastNameAssignment_6_1() { return cCastNameAssignment_6_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.6/@elements.1/@terminal'
+		//FQN
 		public RuleCall getCastNameFQNParserRuleCall_6_1_0() { return cCastNameFQNParserRuleCall_6_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.6/@elements.2'
+		//')'
 		public Keyword getRightParenthesisKeyword_6_2() { return cRightParenthesisKeyword_6_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.7'
+		//'default'
 		public Keyword getDefaultKeyword_7() { return cDefaultKeyword_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.8'
+		//defaultValueLiteral=STRING
 		public Assignment getDefaultValueLiteralAssignment_8() { return cDefaultValueLiteralAssignment_8; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.8/@terminal'
+		//STRING
 		public RuleCall getDefaultValueLiteralSTRINGTerminalRuleCall_8_0() { return cDefaultValueLiteralSTRINGTerminalRuleCall_8_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.9'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_9() { return cDocuAssignment_9; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.8/@alternatives/@elements.9/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_9_0() { return cDocuDocumentationParserRuleCall_9_0; }
 	}
 
@@ -431,67 +476,71 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cLiteralsEnumLiteralParserRuleCall_5_1_1_0 = (RuleCall)cLiteralsAssignment_5_1_1.eContents().get(0);
 		private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/EnumerationType'
+		//EnumerationType:
+		//	'Enumeration' name=ID docu=Documentation? ('of' primitiveType=[PrimitiveType|FQN])? '{' (literals+=EnumLiteral (','
+		//	literals+=EnumLiteral)*)?
+		//	'}';
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives'
+		//'Enumeration' name=ID docu=Documentation? ('of' primitiveType=[PrimitiveType|FQN])? '{' (literals+=EnumLiteral (','
+		//literals+=EnumLiteral)*)? '}'
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.0'
+		//'Enumeration'
 		public Keyword getEnumerationKeyword_0() { return cEnumerationKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.2'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_2() { return cDocuAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.2/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_2_0() { return cDocuDocumentationParserRuleCall_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.3'
+		//('of' primitiveType=[PrimitiveType|FQN])?
 		public Group getGroup_3() { return cGroup_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.3/@elements.0'
+		//'of'
 		public Keyword getOfKeyword_3_0() { return cOfKeyword_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.3/@elements.1'
+		//primitiveType=[PrimitiveType|FQN]
 		public Assignment getPrimitiveTypeAssignment_3_1() { return cPrimitiveTypeAssignment_3_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.3/@elements.1/@terminal'
+		//[PrimitiveType|FQN]
 		public CrossReference getPrimitiveTypePrimitiveTypeCrossReference_3_1_0() { return cPrimitiveTypePrimitiveTypeCrossReference_3_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.3/@elements.1/@terminal/@terminal'
+		//FQN
 		public RuleCall getPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1() { return cPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.4'
+		//'{'
 		public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5'
+		//(literals+=EnumLiteral (',' literals+=EnumLiteral)*)?
 		public Group getGroup_5() { return cGroup_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.0'
+		//literals+=EnumLiteral
 		public Assignment getLiteralsAssignment_5_0() { return cLiteralsAssignment_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.0/@terminal'
+		//EnumLiteral
 		public RuleCall getLiteralsEnumLiteralParserRuleCall_5_0_0() { return cLiteralsEnumLiteralParserRuleCall_5_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.1'
+		//(',' literals+=EnumLiteral)*
 		public Group getGroup_5_1() { return cGroup_5_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.1/@elements.0'
+		//','
 		public Keyword getCommaKeyword_5_1_0() { return cCommaKeyword_5_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.1/@elements.1'
+		//literals+=EnumLiteral
 		public Assignment getLiteralsAssignment_5_1_1() { return cLiteralsAssignment_5_1_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.5/@elements.1/@elements.1/@terminal'
+		//EnumLiteral
 		public RuleCall getLiteralsEnumLiteralParserRuleCall_5_1_1_0() { return cLiteralsEnumLiteralParserRuleCall_5_1_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.9/@alternatives/@elements.6'
+		//'}'
 		public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; }
 	}
 
@@ -505,28 +554,29 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cLiteralAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
 		private final RuleCall cLiteralIntLiteralParserRuleCall_1_1_0 = (RuleCall)cLiteralAssignment_1_1.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/EnumLiteral'
+		//EnumLiteral:
+		//	name=ID ('=' literal=IntLiteral)?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives'
+		//name=ID ('=' literal=IntLiteral)?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.0'
+		//name=ID
 		public Assignment getNameAssignment_0() { return cNameAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.0/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_0_0() { return cNameIDTerminalRuleCall_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.1'
+		//('=' literal=IntLiteral)?
 		public Group getGroup_1() { return cGroup_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.1/@elements.0'
+		//'='
 		public Keyword getEqualsSignKeyword_1_0() { return cEqualsSignKeyword_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.1/@elements.1'
+		//literal=IntLiteral
 		public Assignment getLiteralAssignment_1_1() { return cLiteralAssignment_1_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.10/@alternatives/@elements.1/@elements.1/@terminal'
+		//IntLiteral
 		public RuleCall getLiteralIntLiteralParserRuleCall_1_1_0() { return cLiteralIntLiteralParserRuleCall_1_1_0; }
 	}
 
@@ -546,46 +596,47 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDocuAssignment_5 = (Assignment)cGroup.eContents().get(5);
 		private final RuleCall cDocuDocumentationParserRuleCall_5_0 = (RuleCall)cDocuAssignment_5.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ExternalType'
+		//ExternalType:
+		//	'ExternalType' name=ID '->' targetName=STRING ('default' defaultValueLiteral=STRING)? docu=Documentation?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives'
+		//'ExternalType' name=ID '->' targetName=STRING ('default' defaultValueLiteral=STRING)? docu=Documentation?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.0'
+		//'ExternalType'
 		public Keyword getExternalTypeKeyword_0() { return cExternalTypeKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.2'
+		//'->'
 		public Keyword getHyphenMinusGreaterThanSignKeyword_2() { return cHyphenMinusGreaterThanSignKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.3'
+		//targetName=STRING
 		public Assignment getTargetNameAssignment_3() { return cTargetNameAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.3/@terminal'
+		//STRING
 		public RuleCall getTargetNameSTRINGTerminalRuleCall_3_0() { return cTargetNameSTRINGTerminalRuleCall_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.4'
+		//('default' defaultValueLiteral=STRING)?
 		public Group getGroup_4() { return cGroup_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.4/@elements.0'
+		//'default'
 		public Keyword getDefaultKeyword_4_0() { return cDefaultKeyword_4_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.4/@elements.1'
+		//defaultValueLiteral=STRING
 		public Assignment getDefaultValueLiteralAssignment_4_1() { return cDefaultValueLiteralAssignment_4_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.4/@elements.1/@terminal'
+		//STRING
 		public RuleCall getDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0() { return cDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.5'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_5() { return cDocuAssignment_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.11/@alternatives/@elements.5/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_5_0() { return cDocuDocumentationParserRuleCall_5_0; }
 	}
 
@@ -626,109 +677,116 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cAttributesAttributeParserRuleCall_9_2_0 = (RuleCall)cAttributesAssignment_9_2.eContents().get(0);
 		private final Keyword cRightCurlyBracketKeyword_10 = (Keyword)cGroup.eContents().get(10);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/DataClass'
+		//// TODOHRR: define detail level language?
+		//DataClass:
+		//	'DataClass' name=ID docu=Documentation? ('extends' base=[DataClass|FQN])? '{'
+		//	annotations+=Annotation* ('usercode1' userCode1=DetailCode)? ('usercode2' userCode2=DetailCode)? ('usercode3'
+		//	userCode3=DetailCode)? (operations+=StandardOperation | structors+=ClassStructor | attributes+=Attribute)*
+		//	'}';
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives'
+		//'DataClass' name=ID docu=Documentation? ('extends' base=[DataClass|FQN])? '{' annotations+=Annotation* ('usercode1'
+		//userCode1=DetailCode)? ('usercode2' userCode2=DetailCode)? ('usercode3' userCode3=DetailCode)?
+		//(operations+=StandardOperation | structors+=ClassStructor | attributes+=Attribute)* '}'
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.0'
+		//'DataClass'
 		public Keyword getDataClassKeyword_0() { return cDataClassKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.2'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_2() { return cDocuAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.2/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_2_0() { return cDocuDocumentationParserRuleCall_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.3'
+		//('extends' base=[DataClass|FQN])?
 		public Group getGroup_3() { return cGroup_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.3/@elements.0'
+		//'extends'
 		public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.3/@elements.1'
+		//base=[DataClass|FQN]
 		public Assignment getBaseAssignment_3_1() { return cBaseAssignment_3_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.3/@elements.1/@terminal'
+		//[DataClass|FQN]
 		public CrossReference getBaseDataClassCrossReference_3_1_0() { return cBaseDataClassCrossReference_3_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.3/@elements.1/@terminal/@terminal'
+		//FQN
 		public RuleCall getBaseDataClassFQNParserRuleCall_3_1_0_1() { return cBaseDataClassFQNParserRuleCall_3_1_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.4'
+		//'{'
 		public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.5'
+		//annotations+=Annotation*
 		public Assignment getAnnotationsAssignment_5() { return cAnnotationsAssignment_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.5/@terminal'
+		//Annotation
 		public RuleCall getAnnotationsAnnotationParserRuleCall_5_0() { return cAnnotationsAnnotationParserRuleCall_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.6'
+		//('usercode1' userCode1=DetailCode)?
 		public Group getGroup_6() { return cGroup_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.6/@elements.0'
+		//'usercode1'
 		public Keyword getUsercode1Keyword_6_0() { return cUsercode1Keyword_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.6/@elements.1'
+		//userCode1=DetailCode
 		public Assignment getUserCode1Assignment_6_1() { return cUserCode1Assignment_6_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.6/@elements.1/@terminal'
+		//DetailCode
 		public RuleCall getUserCode1DetailCodeParserRuleCall_6_1_0() { return cUserCode1DetailCodeParserRuleCall_6_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.7'
+		//('usercode2' userCode2=DetailCode)?
 		public Group getGroup_7() { return cGroup_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.7/@elements.0'
+		//'usercode2'
 		public Keyword getUsercode2Keyword_7_0() { return cUsercode2Keyword_7_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.7/@elements.1'
+		//userCode2=DetailCode
 		public Assignment getUserCode2Assignment_7_1() { return cUserCode2Assignment_7_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.7/@elements.1/@terminal'
+		//DetailCode
 		public RuleCall getUserCode2DetailCodeParserRuleCall_7_1_0() { return cUserCode2DetailCodeParserRuleCall_7_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.8'
+		//('usercode3' userCode3=DetailCode)?
 		public Group getGroup_8() { return cGroup_8; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.8/@elements.0'
+		//'usercode3'
 		public Keyword getUsercode3Keyword_8_0() { return cUsercode3Keyword_8_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.8/@elements.1'
+		//userCode3=DetailCode
 		public Assignment getUserCode3Assignment_8_1() { return cUserCode3Assignment_8_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.8/@elements.1/@terminal'
+		//DetailCode
 		public RuleCall getUserCode3DetailCodeParserRuleCall_8_1_0() { return cUserCode3DetailCodeParserRuleCall_8_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9'
+		//(operations+=StandardOperation | structors+=ClassStructor | attributes+=Attribute)*
 		public Alternatives getAlternatives_9() { return cAlternatives_9; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.0'
+		//operations+=StandardOperation
 		public Assignment getOperationsAssignment_9_0() { return cOperationsAssignment_9_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.0/@terminal'
+		//StandardOperation
 		public RuleCall getOperationsStandardOperationParserRuleCall_9_0_0() { return cOperationsStandardOperationParserRuleCall_9_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.1'
+		//structors+=ClassStructor
 		public Assignment getStructorsAssignment_9_1() { return cStructorsAssignment_9_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.1/@terminal'
+		//ClassStructor
 		public RuleCall getStructorsClassStructorParserRuleCall_9_1_0() { return cStructorsClassStructorParserRuleCall_9_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.2'
+		//attributes+=Attribute
 		public Assignment getAttributesAssignment_9_2() { return cAttributesAssignment_9_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.9/@elements.2/@terminal'
+		//Attribute
 		public RuleCall getAttributesAttributeParserRuleCall_9_2_0() { return cAttributesAttributeParserRuleCall_9_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.12/@alternatives/@elements.10'
+		//'}'
 		public Keyword getRightCurlyBracketKeyword_10() { return cRightCurlyBracketKeyword_10; }
 	}
 
@@ -753,61 +811,62 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDocuAssignment_6 = (Assignment)cGroup.eContents().get(6);
 		private final RuleCall cDocuDocumentationParserRuleCall_6_0 = (RuleCall)cDocuAssignment_6.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/Attribute'
+		//Attribute:
+		//	'Attribute' name=ID ('[' size=INT ']')? ':' type=RefableType? ('=' defaultValueLiteral=STRING)? docu=Documentation?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives'
+		//'Attribute' name=ID ('[' size=INT ']')? ':' type=RefableType? ('=' defaultValueLiteral=STRING)? docu=Documentation?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.0'
+		//'Attribute'
 		public Keyword getAttributeKeyword_0() { return cAttributeKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.2'
+		//('[' size=INT ']')?
 		public Group getGroup_2() { return cGroup_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.2/@elements.0'
+		//'['
 		public Keyword getLeftSquareBracketKeyword_2_0() { return cLeftSquareBracketKeyword_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.2/@elements.1'
+		//size=INT
 		public Assignment getSizeAssignment_2_1() { return cSizeAssignment_2_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.2/@elements.1/@terminal'
+		//INT
 		public RuleCall getSizeINTTerminalRuleCall_2_1_0() { return cSizeINTTerminalRuleCall_2_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.2/@elements.2'
+		//']'
 		public Keyword getRightSquareBracketKeyword_2_2() { return cRightSquareBracketKeyword_2_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.3'
+		//':'
 		public Keyword getColonKeyword_3() { return cColonKeyword_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.4'
+		//type=RefableType?
 		public Assignment getTypeAssignment_4() { return cTypeAssignment_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.4/@terminal'
+		//RefableType
 		public RuleCall getTypeRefableTypeParserRuleCall_4_0() { return cTypeRefableTypeParserRuleCall_4_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.5'
+		//('=' defaultValueLiteral=STRING)?
 		public Group getGroup_5() { return cGroup_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.5/@elements.0'
+		//'='
 		public Keyword getEqualsSignKeyword_5_0() { return cEqualsSignKeyword_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.5/@elements.1'
+		//defaultValueLiteral=STRING
 		public Assignment getDefaultValueLiteralAssignment_5_1() { return cDefaultValueLiteralAssignment_5_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.5/@elements.1/@terminal'
+		//STRING
 		public RuleCall getDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0() { return cDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.6'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_6() { return cDocuAssignment_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.13/@alternatives/@elements.6/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_6_0() { return cDocuDocumentationParserRuleCall_6_0; }
 	}
 
@@ -1049,25 +1108,25 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//'sends'
 		public Keyword getSendsKeyword_5_1_0() { return cSendsKeyword_5_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.5/@elements.1/@elements.1'
+		//sendsMsg=[Message]
 		public Assignment getSendsMsgAssignment_5_1_1() { return cSendsMsgAssignment_5_1_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.5/@elements.1/@elements.1/@terminal'
+		//[Message]
 		public CrossReference getSendsMsgMessageCrossReference_5_1_1_0() { return cSendsMsgMessageCrossReference_5_1_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.5/@elements.1/@elements.1/@terminal/@terminal'
+		//ID
 		public RuleCall getSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1() { return cSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.6'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_6() { return cDocuAssignment_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.6/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_6_0() { return cDocuDocumentationParserRuleCall_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.7'
+		//detailCode=DetailCode
 		public Assignment getDetailCodeAssignment_7() { return cDetailCodeAssignment_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.16/@alternatives/@elements.7/@terminal'
+		//DetailCode
 		public RuleCall getDetailCodeDetailCodeParserRuleCall_7_0() { return cDetailCodeDetailCodeParserRuleCall_7_0; }
 	}
 
@@ -1081,28 +1140,29 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDetailCodeAssignment_1 = (Assignment)cGroup.eContents().get(1);
 		private final RuleCall cDetailCodeDetailCodeParserRuleCall_1_0 = (RuleCall)cDetailCodeAssignment_1.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ClassStructor'
+		//ClassStructor:
+		//	name=('ctor' | 'dtor') detailCode=DetailCode;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives'
+		//name=('ctor' | 'dtor') detailCode=DetailCode
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.0'
+		//name=('ctor' | 'dtor')
 		public Assignment getNameAssignment_0() { return cNameAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.0/@terminal'
+		//('ctor' | 'dtor')
 		public Alternatives getNameAlternatives_0_0() { return cNameAlternatives_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.0/@terminal/@elements.0'
+		//'ctor'
 		public Keyword getNameCtorKeyword_0_0_0() { return cNameCtorKeyword_0_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.0/@terminal/@elements.1'
+		//'dtor'
 		public Keyword getNameDtorKeyword_0_0_1() { return cNameDtorKeyword_0_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.1'
+		//detailCode=DetailCode
 		public Assignment getDetailCodeAssignment_1() { return cDetailCodeAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.17/@alternatives/@elements.1/@terminal'
+		//DetailCode
 		public RuleCall getDetailCodeDetailCodeParserRuleCall_1_0() { return cDetailCodeDetailCodeParserRuleCall_1_0; }
 	}
 
@@ -1112,16 +1172,17 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cProtocolClassParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cCompoundProtocolClassParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/GeneralProtocolClass'
+		//GeneralProtocolClass:
+		//	ProtocolClass | CompoundProtocolClass;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.19/@alternatives'
+		//ProtocolClass | CompoundProtocolClass
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.19/@alternatives/@elements.0'
+		//ProtocolClass
 		public RuleCall getProtocolClassParserRuleCall_0() { return cProtocolClassParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.19/@alternatives/@elements.1'
+		//CompoundProtocolClass
 		public RuleCall getCompoundProtocolClassParserRuleCall_1() { return cCompoundProtocolClassParserRuleCall_1; }
 	}
 
@@ -1181,76 +1242,87 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cSemanticsProtocolSemanticsParserRuleCall_14_0 = (RuleCall)cSemanticsAssignment_14.eContents().get(0);
 		private final Keyword cRightCurlyBracketKeyword_15 = (Keyword)cGroup.eContents().get(15);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ProtocolClass'
+		//ProtocolClass:
+		//	commType=CommunicationType?
+		//	'ProtocolClass' name=ID docu=Documentation? ('extends' base=[ProtocolClass|FQN])? '{'
+		//	annotations+=Annotation* ('usercode1' userCode1=DetailCode)? ('usercode2' userCode2=DetailCode)? ('usercode3'
+		//	userCode3=DetailCode)? ('incoming' '{' incomingMessages+=Message* '}')? ('outgoing' '{' outgoingMessages+=Message*
+		//	'}')? ('regular' 'PortClass' regular=PortClass)? ('conjugated' 'PortClass' conjugated=PortClass)?
+		//	semantics=ProtocolSemantics?
+		//	'}';
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives'
+		//commType=CommunicationType? 'ProtocolClass' name=ID docu=Documentation? ('extends' base=[ProtocolClass|FQN])? '{'
+		//annotations+=Annotation* ('usercode1' userCode1=DetailCode)? ('usercode2' userCode2=DetailCode)? ('usercode3'
+		//userCode3=DetailCode)? ('incoming' '{' incomingMessages+=Message* '}')? ('outgoing' '{' outgoingMessages+=Message*
+		//'}')? ('regular' 'PortClass' regular=PortClass)? ('conjugated' 'PortClass' conjugated=PortClass)?
+		//semantics=ProtocolSemantics? '}'
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.0'
+		//commType=CommunicationType?
 		public Assignment getCommTypeAssignment_0() { return cCommTypeAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.0/@terminal'
+		//CommunicationType
 		public RuleCall getCommTypeCommunicationTypeEnumRuleCall_0_0() { return cCommTypeCommunicationTypeEnumRuleCall_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.1'
+		//'ProtocolClass'
 		public Keyword getProtocolClassKeyword_1() { return cProtocolClassKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.2'
+		//name=ID
 		public Assignment getNameAssignment_2() { return cNameAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.2/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.3'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_3() { return cDocuAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.3/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_3_0() { return cDocuDocumentationParserRuleCall_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.4'
+		//('extends' base=[ProtocolClass|FQN])?
 		public Group getGroup_4() { return cGroup_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.4/@elements.0'
+		//'extends'
 		public Keyword getExtendsKeyword_4_0() { return cExtendsKeyword_4_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.4/@elements.1'
+		//base=[ProtocolClass|FQN]
 		public Assignment getBaseAssignment_4_1() { return cBaseAssignment_4_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.4/@elements.1/@terminal'
+		//[ProtocolClass|FQN]
 		public CrossReference getBaseProtocolClassCrossReference_4_1_0() { return cBaseProtocolClassCrossReference_4_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.4/@elements.1/@terminal/@terminal'
+		//FQN
 		public RuleCall getBaseProtocolClassFQNParserRuleCall_4_1_0_1() { return cBaseProtocolClassFQNParserRuleCall_4_1_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.5'
+		//'{'
 		public Keyword getLeftCurlyBracketKeyword_5() { return cLeftCurlyBracketKeyword_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.6'
+		//annotations+=Annotation*
 		public Assignment getAnnotationsAssignment_6() { return cAnnotationsAssignment_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.6/@terminal'
+		//Annotation
 		public RuleCall getAnnotationsAnnotationParserRuleCall_6_0() { return cAnnotationsAnnotationParserRuleCall_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.7'
+		//('usercode1' userCode1=DetailCode)?
 		public Group getGroup_7() { return cGroup_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.7/@elements.0'
+		//'usercode1'
 		public Keyword getUsercode1Keyword_7_0() { return cUsercode1Keyword_7_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.7/@elements.1'
+		//userCode1=DetailCode
 		public Assignment getUserCode1Assignment_7_1() { return cUserCode1Assignment_7_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.7/@elements.1/@terminal'
+		//DetailCode
 		public RuleCall getUserCode1DetailCodeParserRuleCall_7_1_0() { return cUserCode1DetailCodeParserRuleCall_7_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.8'
+		//('usercode2' userCode2=DetailCode)?
 		public Group getGroup_8() { return cGroup_8; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.8/@elements.0'
+		//'usercode2'
 		public Keyword getUsercode2Keyword_8_0() { return cUsercode2Keyword_8_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.20/@alternatives/@elements.8/@elements.1'
+		//userCode2=DetailCode
 		public Assignment getUserCode2Assignment_8_1() { return cUserCode2Assignment_8_1; }
 
 		//DetailCode
@@ -1451,21 +1523,22 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Keyword cMessageKeyword_1 = (Keyword)cGroup.eContents().get(1);
 		private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2);
 		private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0);
-		private final Keyword cLeftParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
-		private final Assignment cDataAssignment_4 = (Assignment)cGroup.eContents().get(4);
-		private final RuleCall cDataVarDeclParserRuleCall_4_0 = (RuleCall)cDataAssignment_4.eContents().get(0);
-		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
-		private final Assignment cAnnotationsAssignment_6 = (Assignment)cGroup.eContents().get(6);
-		private final RuleCall cAnnotationsAnnotationParserRuleCall_6_0 = (RuleCall)cAnnotationsAssignment_6.eContents().get(0);
-		private final Assignment cDocuAssignment_7 = (Assignment)cGroup.eContents().get(7);
-		private final RuleCall cDocuDocumentationParserRuleCall_7_0 = (RuleCall)cDocuAssignment_7.eContents().get(0);
+		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
+		private final Keyword cLeftParenthesisKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
+		private final Assignment cDataAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
+		private final RuleCall cDataMessageDataParserRuleCall_3_1_0 = (RuleCall)cDataAssignment_3_1.eContents().get(0);
+		private final Keyword cRightParenthesisKeyword_3_2 = (Keyword)cGroup_3.eContents().get(2);
+		private final Assignment cAnnotationsAssignment_4 = (Assignment)cGroup.eContents().get(4);
+		private final RuleCall cAnnotationsAnnotationParserRuleCall_4_0 = (RuleCall)cAnnotationsAssignment_4.eContents().get(0);
+		private final Assignment cDocuAssignment_5 = (Assignment)cGroup.eContents().get(5);
+		private final RuleCall cDocuDocumentationParserRuleCall_5_0 = (RuleCall)cDocuAssignment_5.eContents().get(0);
 		
 		//Message:
-		//	priv?='private'? 'Message' name=ID '(' data=VarDecl? ')' annotations+=Annotation*
+		//	priv?='private'? 'Message' name=ID ('(' data=MessageData? ')')? annotations+=Annotation*
 		//	docu=Documentation?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//priv?='private'? 'Message' name=ID '(' data=VarDecl? ')' annotations+=Annotation* docu=Documentation?
+		//priv?='private'? 'Message' name=ID ('(' data=MessageData? ')')? annotations+=Annotation* docu=Documentation?
 		public Group getGroup() { return cGroup; }
 
 		//priv?='private'?
@@ -1483,29 +1556,32 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//ID
 		public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; }
 
+		//('(' data=MessageData? ')')?
+		public Group getGroup_3() { return cGroup_3; }
+
 		//'('
-		public Keyword getLeftParenthesisKeyword_3() { return cLeftParenthesisKeyword_3; }
+		public Keyword getLeftParenthesisKeyword_3_0() { return cLeftParenthesisKeyword_3_0; }
 
-		//data=VarDecl?
-		public Assignment getDataAssignment_4() { return cDataAssignment_4; }
+		//data=MessageData?
+		public Assignment getDataAssignment_3_1() { return cDataAssignment_3_1; }
 
-		//VarDecl
-		public RuleCall getDataVarDeclParserRuleCall_4_0() { return cDataVarDeclParserRuleCall_4_0; }
+		//MessageData
+		public RuleCall getDataMessageDataParserRuleCall_3_1_0() { return cDataMessageDataParserRuleCall_3_1_0; }
 
 		//')'
-		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
+		public Keyword getRightParenthesisKeyword_3_2() { return cRightParenthesisKeyword_3_2; }
 
 		//annotations+=Annotation*
-		public Assignment getAnnotationsAssignment_6() { return cAnnotationsAssignment_6; }
+		public Assignment getAnnotationsAssignment_4() { return cAnnotationsAssignment_4; }
 
 		//Annotation
-		public RuleCall getAnnotationsAnnotationParserRuleCall_6_0() { return cAnnotationsAnnotationParserRuleCall_6_0; }
+		public RuleCall getAnnotationsAnnotationParserRuleCall_4_0() { return cAnnotationsAnnotationParserRuleCall_4_0; }
 
 		//docu=Documentation?
-		public Assignment getDocuAssignment_7() { return cDocuAssignment_7; }
+		public Assignment getDocuAssignment_5() { return cDocuAssignment_5; }
 
 		//Documentation
-		public RuleCall getDocuDocumentationParserRuleCall_7_0() { return cDocuDocumentationParserRuleCall_7_0; }
+		public RuleCall getDocuDocumentationParserRuleCall_5_0() { return cDocuDocumentationParserRuleCall_5_0; }
 	}
 
 	public class PortClassElements extends AbstractParserRuleElementFinder {
@@ -1586,16 +1662,17 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cInMessageHandlerParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cOutMessageHandlerParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/InMessageHandler'
+		//MessageHandler:
+		//	InMessageHandler | OutMessageHandler;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.25/@alternatives'
+		//InMessageHandler | OutMessageHandler
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.25/@alternatives/@elements.0'
+		//InMessageHandler
 		public RuleCall getInMessageHandlerParserRuleCall_0() { return cInMessageHandlerParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.25/@alternatives/@elements.1'
+		//OutMessageHandler
 		public RuleCall getOutMessageHandlerParserRuleCall_1() { return cOutMessageHandlerParserRuleCall_1; }
 	}
 
@@ -1610,31 +1687,32 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDetailCodeAssignment_3 = (Assignment)cGroup.eContents().get(3);
 		private final RuleCall cDetailCodeDetailCodeParserRuleCall_3_0 = (RuleCall)cDetailCodeAssignment_3.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/InMessageHandler'
+		//InMessageHandler:
+		//	'handle' 'incoming' msg=[Message] detailCode=DetailCode;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives'
+		//'handle' 'incoming' msg=[Message] detailCode=DetailCode
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.0'
+		//'handle'
 		public Keyword getHandleKeyword_0() { return cHandleKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.1'
+		//'incoming'
 		public Keyword getIncomingKeyword_1() { return cIncomingKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.2'
+		//msg=[Message]
 		public Assignment getMsgAssignment_2() { return cMsgAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.2/@terminal'
+		//[Message]
 		public CrossReference getMsgMessageCrossReference_2_0() { return cMsgMessageCrossReference_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.2/@terminal/@terminal'
+		//ID
 		public RuleCall getMsgMessageIDTerminalRuleCall_2_0_1() { return cMsgMessageIDTerminalRuleCall_2_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.3'
+		//detailCode=DetailCode
 		public Assignment getDetailCodeAssignment_3() { return cDetailCodeAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.26/@alternatives/@elements.3/@terminal'
+		//DetailCode
 		public RuleCall getDetailCodeDetailCodeParserRuleCall_3_0() { return cDetailCodeDetailCodeParserRuleCall_3_0; }
 	}
 
@@ -1649,31 +1727,32 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDetailCodeAssignment_3 = (Assignment)cGroup.eContents().get(3);
 		private final RuleCall cDetailCodeDetailCodeParserRuleCall_3_0 = (RuleCall)cDetailCodeAssignment_3.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/OutMessageHandler'
+		//OutMessageHandler:
+		//	'handle' 'outgoing' msg=[Message] detailCode=DetailCode;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives'
+		//'handle' 'outgoing' msg=[Message] detailCode=DetailCode
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.0'
+		//'handle'
 		public Keyword getHandleKeyword_0() { return cHandleKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.1'
+		//'outgoing'
 		public Keyword getOutgoingKeyword_1() { return cOutgoingKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.2'
+		//msg=[Message]
 		public Assignment getMsgAssignment_2() { return cMsgAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.2/@terminal'
+		//[Message]
 		public CrossReference getMsgMessageCrossReference_2_0() { return cMsgMessageCrossReference_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.2/@terminal/@terminal'
+		//ID
 		public RuleCall getMsgMessageIDTerminalRuleCall_2_0_1() { return cMsgMessageIDTerminalRuleCall_2_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.3'
+		//detailCode=DetailCode
 		public Assignment getDetailCodeAssignment_3() { return cDetailCodeAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.27/@alternatives/@elements.3/@terminal'
+		//DetailCode
 		public RuleCall getDetailCodeDetailCodeParserRuleCall_3_0() { return cDetailCodeDetailCodeParserRuleCall_3_0; }
 	}
 
@@ -1681,10 +1760,11 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.etrice.core.Room.ModelComponent");
 		private final RuleCall cActorClassParserRuleCall = (RuleCall)rule.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ModelComponent'
+		//@ Override ModelComponent:
+		//	ActorClass;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.28/@alternatives'
+		//ActorClass
 		public RuleCall getActorClassParserRuleCall() { return cActorClassParserRuleCall; }
 	}
 
@@ -2051,19 +2131,20 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cSAPParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		private final RuleCall cSPPParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/SAP'
+		//InterfaceItem:
+		//	Port | SAP | SPP;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.30/@alternatives'
+		//Port | SAP | SPP
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.30/@alternatives/@elements.0'
+		//Port
 		public RuleCall getPortParserRuleCall_0() { return cPortParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.30/@alternatives/@elements.1'
+		//SAP
 		public RuleCall getSAPParserRuleCall_1() { return cSAPParserRuleCall_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.30/@alternatives/@elements.2'
+		//SPP
 		public RuleCall getSPPParserRuleCall_2() { return cSPPParserRuleCall_2; }
 	}
 
@@ -2086,55 +2167,58 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cDocuAssignment_7 = (Assignment)cGroup.eContents().get(7);
 		private final RuleCall cDocuDocumentationParserRuleCall_7_0 = (RuleCall)cDocuAssignment_7.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/Port'
+		//Port:
+		//	conjugated?='conjugated'? 'Port' name=ID multiplicity=MULTIPLICITY? ':' protocol=[GeneralProtocolClass|FQN]
+		//	annotations+=Annotation* docu=Documentation?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives'
+		//conjugated?='conjugated'? 'Port' name=ID multiplicity=MULTIPLICITY? ':' protocol=[GeneralProtocolClass|FQN]
+		//annotations+=Annotation* docu=Documentation?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.0'
+		//conjugated?='conjugated'?
 		public Assignment getConjugatedAssignment_0() { return cConjugatedAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.0/@terminal'
+		//'conjugated'
 		public Keyword getConjugatedConjugatedKeyword_0_0() { return cConjugatedConjugatedKeyword_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.1'
+		//'Port'
 		public Keyword getPortKeyword_1() { return cPortKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.2'
+		//name=ID
 		public Assignment getNameAssignment_2() { return cNameAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.2/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.3'
+		//multiplicity=MULTIPLICITY?
 		public Assignment getMultiplicityAssignment_3() { return cMultiplicityAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.3/@terminal'
+		//MULTIPLICITY
 		public RuleCall getMultiplicityMULTIPLICITYParserRuleCall_3_0() { return cMultiplicityMULTIPLICITYParserRuleCall_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.4'
+		//':'
 		public Keyword getColonKeyword_4() { return cColonKeyword_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.5'
+		//protocol=[GeneralProtocolClass|FQN]
 		public Assignment getProtocolAssignment_5() { return cProtocolAssignment_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.5/@terminal'
+		//[GeneralProtocolClass|FQN]
 		public CrossReference getProtocolGeneralProtocolClassCrossReference_5_0() { return cProtocolGeneralProtocolClassCrossReference_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.5/@terminal/@terminal'
+		//FQN
 		public RuleCall getProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1() { return cProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.6'
+		//annotations+=Annotation*
 		public Assignment getAnnotationsAssignment_6() { return cAnnotationsAssignment_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.6/@terminal'
+		//Annotation
 		public RuleCall getAnnotationsAnnotationParserRuleCall_6_0() { return cAnnotationsAnnotationParserRuleCall_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.7'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_7() { return cDocuAssignment_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.31/@alternatives/@elements.7/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_7_0() { return cDocuDocumentationParserRuleCall_7_0; }
 	}
 
@@ -2147,25 +2231,26 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cInterfacePortPortCrossReference_2_0 = (CrossReference)cInterfacePortAssignment_2.eContents().get(0);
 		private final RuleCall cInterfacePortPortIDTerminalRuleCall_2_0_1 = (RuleCall)cInterfacePortPortCrossReference_2_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ExternalPort'
+		//ExternalPort:
+		//	'external' 'Port' interfacePort=[Port];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives'
+		//'external' 'Port' interfacePort=[Port]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives/@elements.0'
+		//'external'
 		public Keyword getExternalKeyword_0() { return cExternalKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives/@elements.1'
+		//'Port'
 		public Keyword getPortKeyword_1() { return cPortKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives/@elements.2'
+		//interfacePort=[Port]
 		public Assignment getInterfacePortAssignment_2() { return cInterfacePortAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives/@elements.2/@terminal'
+		//[Port]
 		public CrossReference getInterfacePortPortCrossReference_2_0() { return cInterfacePortPortCrossReference_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.32/@alternatives/@elements.2/@terminal/@terminal'
+		//ID
 		public RuleCall getInterfacePortPortIDTerminalRuleCall_2_0_1() { return cInterfacePortPortIDTerminalRuleCall_2_0_1; }
 	}
 
@@ -2180,31 +2265,32 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cProtocolProtocolClassCrossReference_3_0 = (CrossReference)cProtocolAssignment_3.eContents().get(0);
 		private final RuleCall cProtocolProtocolClassFQNParserRuleCall_3_0_1 = (RuleCall)cProtocolProtocolClassCrossReference_3_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/SAP'
+		//SAP:
+		//	'SAP' name=ID ':' protocol=[ProtocolClass|FQN];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives'
+		//'SAP' name=ID ':' protocol=[ProtocolClass|FQN]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.0'
+		//'SAP'
 		public Keyword getSAPKeyword_0() { return cSAPKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.2'
+		//':'
 		public Keyword getColonKeyword_2() { return cColonKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.3'
+		//protocol=[ProtocolClass|FQN]
 		public Assignment getProtocolAssignment_3() { return cProtocolAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.3/@terminal'
+		//[ProtocolClass|FQN]
 		public CrossReference getProtocolProtocolClassCrossReference_3_0() { return cProtocolProtocolClassCrossReference_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.33/@alternatives/@elements.3/@terminal/@terminal'
+		//FQN
 		public RuleCall getProtocolProtocolClassFQNParserRuleCall_3_0_1() { return cProtocolProtocolClassFQNParserRuleCall_3_0_1; }
 	}
 
@@ -2219,31 +2305,32 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cProtocolProtocolClassCrossReference_3_0 = (CrossReference)cProtocolAssignment_3.eContents().get(0);
 		private final RuleCall cProtocolProtocolClassFQNParserRuleCall_3_0_1 = (RuleCall)cProtocolProtocolClassCrossReference_3_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/SPP'
+		//SPP:
+		//	'SPP' name=ID ':' protocol=[ProtocolClass|FQN];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives'
+		//'SPP' name=ID ':' protocol=[ProtocolClass|FQN]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.0'
+		//'SPP'
 		public Keyword getSPPKeyword_0() { return cSPPKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.2'
+		//':'
 		public Keyword getColonKeyword_2() { return cColonKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.3'
+		//protocol=[ProtocolClass|FQN]
 		public Assignment getProtocolAssignment_3() { return cProtocolAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.3/@terminal'
+		//[ProtocolClass|FQN]
 		public CrossReference getProtocolProtocolClassCrossReference_3_0() { return cProtocolProtocolClassCrossReference_3_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.34/@alternatives/@elements.3/@terminal/@terminal'
+		//FQN
 		public RuleCall getProtocolProtocolClassFQNParserRuleCall_3_0_1() { return cProtocolProtocolClassFQNParserRuleCall_3_0_1; }
 	}
 
@@ -2256,25 +2343,26 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cSppSPPCrossReference_2_0 = (CrossReference)cSppAssignment_2.eContents().get(0);
 		private final RuleCall cSppSPPIDTerminalRuleCall_2_0_1 = (RuleCall)cSppSPPCrossReference_2_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ServiceImplementation'
+		//ServiceImplementation:
+		//	'ServiceImplementation' 'of' spp=[SPP];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives'
+		//'ServiceImplementation' 'of' spp=[SPP]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives/@elements.0'
+		//'ServiceImplementation'
 		public Keyword getServiceImplementationKeyword_0() { return cServiceImplementationKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives/@elements.1'
+		//'of'
 		public Keyword getOfKeyword_1() { return cOfKeyword_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives/@elements.2'
+		//spp=[SPP]
 		public Assignment getSppAssignment_2() { return cSppAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives/@elements.2/@terminal'
+		//[SPP]
 		public CrossReference getSppSPPCrossReference_2_0() { return cSppSPPCrossReference_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.35/@alternatives/@elements.2/@terminal/@terminal'
+		//ID
 		public RuleCall getSppSPPIDTerminalRuleCall_2_0_1() { return cSppSPPIDTerminalRuleCall_2_0_1; }
 	}
 
@@ -2298,58 +2386,62 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cSubSystemsSubSystemRefParserRuleCall_5_2_0 = (RuleCall)cSubSystemsAssignment_5_2.eContents().get(0);
 		private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/LogicalSystem'
+		//LogicalSystem:
+		//	'LogicalSystem' name=ID docu=Documentation? '{'
+		//	annotations+=Annotation* (connections+=LayerConnection | bindings+=Binding | subSystems+=SubSystemRef)*
+		//	'}';
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives'
+		//'LogicalSystem' name=ID docu=Documentation? '{' annotations+=Annotation* (connections+=LayerConnection |
+		//bindings+=Binding | subSystems+=SubSystemRef)* '}'
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.0'
+		//'LogicalSystem'
 		public Keyword getLogicalSystemKeyword_0() { return cLogicalSystemKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.1'
+		//name=ID
 		public Assignment getNameAssignment_1() { return cNameAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.1/@terminal'
+		//ID
 		public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.2'
+		//docu=Documentation?
 		public Assignment getDocuAssignment_2() { return cDocuAssignment_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.2/@terminal'
+		//Documentation
 		public RuleCall getDocuDocumentationParserRuleCall_2_0() { return cDocuDocumentationParserRuleCall_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.3'
+		//'{'
 		public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.4'
+		//annotations+=Annotation*
 		public Assignment getAnnotationsAssignment_4() { return cAnnotationsAssignment_4; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.4/@terminal'
+		//Annotation
 		public RuleCall getAnnotationsAnnotationParserRuleCall_4_0() { return cAnnotationsAnnotationParserRuleCall_4_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5'
+		//(connections+=LayerConnection | bindings+=Binding | subSystems+=SubSystemRef)*
 		public Alternatives getAlternatives_5() { return cAlternatives_5; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.0'
+		//connections+=LayerConnection
 		public Assignment getConnectionsAssignment_5_0() { return cConnectionsAssignment_5_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.0/@terminal'
+		//LayerConnection
 		public RuleCall getConnectionsLayerConnectionParserRuleCall_5_0_0() { return cConnectionsLayerConnectionParserRuleCall_5_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.1'
+		//bindings+=Binding
 		public Assignment getBindingsAssignment_5_1() { return cBindingsAssignment_5_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.1/@terminal'
+		//Binding
 		public RuleCall getBindingsBindingParserRuleCall_5_1_0() { return cBindingsBindingParserRuleCall_5_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.2'
+		//subSystems+=SubSystemRef
 		public Assignment getSubSystemsAssignment_5_2() { return cSubSystemsAssignment_5_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.5/@elements.2/@terminal'
+		//SubSystemRef
 		public RuleCall getSubSystemsSubSystemRefParserRuleCall_5_2_0() { return cSubSystemsSubSystemRefParserRuleCall_5_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.36/@alternatives/@elements.6'
+		//'}'
 		public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; }
 	}
 
@@ -2359,7 +2451,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cSubSystemRefParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cActorRefParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/ActorContainerRef'
+		//ActorContainerRef:
+		//	SubSystemRef | ActorRef;
 		@Override public ParserRule getRule() { return rule; }
 
 		//SubSystemRef | ActorRef
@@ -2734,13 +2827,13 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//(':' idx=INT)?
 		public Group getGroup_1() { return cGroup_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.43/@alternatives/@elements.1/@elements.0'
+		//':'
 		public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.43/@alternatives/@elements.1/@elements.1'
+		//idx=INT
 		public Assignment getIdxAssignment_1_1() { return cIdxAssignment_1_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.43/@alternatives/@elements.1/@elements.1/@terminal'
+		//INT
 		public RuleCall getIdxINTTerminalRuleCall_1_1_0() { return cIdxINTTerminalRuleCall_1_1_0; }
 	}
 
@@ -2754,28 +2847,29 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cEndpoint2Assignment_3 = (Assignment)cGroup.eContents().get(3);
 		private final RuleCall cEndpoint2BindingEndPointParserRuleCall_3_0 = (RuleCall)cEndpoint2Assignment_3.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/Binding'
+		//Binding:
+		//	'Binding' endpoint1=BindingEndPoint 'and' endpoint2=BindingEndPoint;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives'
+		//'Binding' endpoint1=BindingEndPoint 'and' endpoint2=BindingEndPoint
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.0'
+		//'Binding'
 		public Keyword getBindingKeyword_0() { return cBindingKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.1'
+		//endpoint1=BindingEndPoint
 		public Assignment getEndpoint1Assignment_1() { return cEndpoint1Assignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.1/@terminal'
+		//BindingEndPoint
 		public RuleCall getEndpoint1BindingEndPointParserRuleCall_1_0() { return cEndpoint1BindingEndPointParserRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.2'
+		//'and'
 		public Keyword getAndKeyword_2() { return cAndKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.3'
+		//endpoint2=BindingEndPoint
 		public Assignment getEndpoint2Assignment_3() { return cEndpoint2Assignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.44/@alternatives/@elements.3/@terminal'
+		//BindingEndPoint
 		public RuleCall getEndpoint2BindingEndPointParserRuleCall_3_0() { return cEndpoint2BindingEndPointParserRuleCall_3_0; }
 	}
 
@@ -2796,49 +2890,50 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cSubSubProtocolCrossReference_2_1_0 = (CrossReference)cSubAssignment_2_1.eContents().get(0);
 		private final RuleCall cSubSubProtocolIDTerminalRuleCall_2_1_0_1 = (RuleCall)cSubSubProtocolCrossReference_2_1_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/BindingEndPoint'
+		//BindingEndPoint:
+		//	(actorRef=[ActorContainerRef] '.')? port=[Port] ('sub' sub=[SubProtocol])?;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives'
+		//(actorRef=[ActorContainerRef] '.')? port=[Port] ('sub' sub=[SubProtocol])?
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.0'
+		//(actorRef=[ActorContainerRef] '.')?
 		public Group getGroup_0() { return cGroup_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.0/@elements.0'
+		//actorRef=[ActorContainerRef]
 		public Assignment getActorRefAssignment_0_0() { return cActorRefAssignment_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.0/@elements.0/@terminal'
+		//[ActorContainerRef]
 		public CrossReference getActorRefActorContainerRefCrossReference_0_0_0() { return cActorRefActorContainerRefCrossReference_0_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.0/@elements.0/@terminal/@terminal'
+		//ID
 		public RuleCall getActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1() { return cActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.0/@elements.1'
+		//'.'
 		public Keyword getFullStopKeyword_0_1() { return cFullStopKeyword_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.1'
+		//port=[Port]
 		public Assignment getPortAssignment_1() { return cPortAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.1/@terminal'
+		//[Port]
 		public CrossReference getPortPortCrossReference_1_0() { return cPortPortCrossReference_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.1/@terminal/@terminal'
+		//ID
 		public RuleCall getPortPortIDTerminalRuleCall_1_0_1() { return cPortPortIDTerminalRuleCall_1_0_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.2'
+		//('sub' sub=[SubProtocol])?
 		public Group getGroup_2() { return cGroup_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.2/@elements.0'
+		//'sub'
 		public Keyword getSubKeyword_2_0() { return cSubKeyword_2_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.2/@elements.1'
+		//sub=[SubProtocol]
 		public Assignment getSubAssignment_2_1() { return cSubAssignment_2_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.2/@elements.1/@terminal'
+		//[SubProtocol]
 		public CrossReference getSubSubProtocolCrossReference_2_1_0() { return cSubSubProtocolCrossReference_2_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.45/@alternatives/@elements.2/@elements.1/@terminal/@terminal'
+		//ID
 		public RuleCall getSubSubProtocolIDTerminalRuleCall_2_1_0_1() { return cSubSubProtocolIDTerminalRuleCall_2_1_0_1; }
 	}
 
@@ -2852,28 +2947,29 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Assignment cToAssignment_3 = (Assignment)cGroup.eContents().get(3);
 		private final RuleCall cToSPPointParserRuleCall_3_0 = (RuleCall)cToAssignment_3.eContents().get(0);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/LayerConnection'
+		//LayerConnection:
+		//	'LayerConnection' from=SAPoint 'satisfied_by' to=SPPoint;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives'
+		//'LayerConnection' from=SAPoint 'satisfied_by' to=SPPoint
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.0'
+		//'LayerConnection'
 		public Keyword getLayerConnectionKeyword_0() { return cLayerConnectionKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.1'
+		//from=SAPoint
 		public Assignment getFromAssignment_1() { return cFromAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.1/@terminal'
+		//SAPoint
 		public RuleCall getFromSAPointParserRuleCall_1_0() { return cFromSAPointParserRuleCall_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.2'
+		//'satisfied_by'
 		public Keyword getSatisfied_byKeyword_2() { return cSatisfied_byKeyword_2; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.3'
+		//to=SPPoint
 		public Assignment getToAssignment_3() { return cToAssignment_3; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.46/@alternatives/@elements.3/@terminal'
+		//SPPoint
 		public RuleCall getToSPPointParserRuleCall_3_0() { return cToSPPointParserRuleCall_3_0; }
 	}
 
@@ -2883,16 +2979,17 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final RuleCall cRefSAPointParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cRelaySAPointParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/SAPoint'
+		//SAPoint:
+		//	RefSAPoint | RelaySAPoint;
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.47/@alternatives'
+		//RefSAPoint | RelaySAPoint
 		public Alternatives getAlternatives() { return cAlternatives; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.47/@alternatives/@elements.0'
+		//RefSAPoint
 		public RuleCall getRefSAPointParserRuleCall_0() { return cRefSAPointParserRuleCall_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.47/@alternatives/@elements.1'
+		//RelaySAPoint
 		public RuleCall getRelaySAPointParserRuleCall_1() { return cRelaySAPointParserRuleCall_1; }
 	}
 
@@ -2904,22 +3001,25 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cRefActorContainerRefCrossReference_1_0 = (CrossReference)cRefAssignment_1.eContents().get(0);
 		private final RuleCall cRefActorContainerRefIDTerminalRuleCall_1_0_1 = (RuleCall)cRefActorContainerRefCrossReference_1_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/RefSAPoint'
+		//RefSAPoint: // satisfies a sub actor
+		//	'ref' ref=[ActorContainerRef];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.48/@alternatives'
+		//// satisfies a sub actor
+		//'ref' ref=[ActorContainerRef]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.48/@alternatives/@elements.0'
+		//// satisfies a sub actor
+		//'ref'
 		public Keyword getRefKeyword_0() { return cRefKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.48/@alternatives/@elements.1'
+		//ref=[ActorContainerRef]
 		public Assignment getRefAssignment_1() { return cRefAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.48/@alternatives/@elements.1/@terminal'
+		//[ActorContainerRef]
 		public CrossReference getRefActorContainerRefCrossReference_1_0() { return cRefActorContainerRefCrossReference_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.48/@alternatives/@elements.1/@terminal/@terminal'
+		//ID
 		public RuleCall getRefActorContainerRefIDTerminalRuleCall_1_0_1() { return cRefActorContainerRefIDTerminalRuleCall_1_0_1; }
 	}
 
@@ -2931,22 +3031,25 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cRelaySPPCrossReference_1_0 = (CrossReference)cRelayAssignment_1.eContents().get(0);
 		private final RuleCall cRelaySPPIDTerminalRuleCall_1_0_1 = (RuleCall)cRelaySPPCrossReference_1_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/RelaySAPoint'
+		//RelaySAPoint: // relays from own interface
+		//	'relay_sap' relay=[SPP];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.49/@alternatives'
+		//// relays from own interface
+		//'relay_sap' relay=[SPP]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.49/@alternatives/@elements.0'
+		//// relays from own interface
+		//'relay_sap'
 		public Keyword getRelay_sapKeyword_0() { return cRelay_sapKeyword_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.49/@alternatives/@elements.1'
+		//relay=[SPP]
 		public Assignment getRelayAssignment_1() { return cRelayAssignment_1; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.49/@alternatives/@elements.1/@terminal'
+		//[SPP]
 		public CrossReference getRelaySPPCrossReference_1_0() { return cRelaySPPCrossReference_1_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.49/@alternatives/@elements.1/@terminal/@terminal'
+		//ID
 		public RuleCall getRelaySPPIDTerminalRuleCall_1_0_1() { return cRelaySPPIDTerminalRuleCall_1_0_1; }
 	}
 
@@ -2961,19 +3064,20 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final CrossReference cServiceSPPCrossReference_2_0 = (CrossReference)cServiceAssignment_2.eContents().get(0);
 		private final RuleCall cServiceSPPIDTerminalRuleCall_2_0_1 = (RuleCall)cServiceSPPCrossReference_2_0.eContents().get(1);
 		
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#XtextFragmentProvider_org.eclipse.etrice.core.Room/SPPoint'
+		//SPPoint:
+		//	ref=[ActorContainerRef] '.' service=[SPP];
 		@Override public ParserRule getRule() { return rule; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.50/@alternatives'
+		//ref=[ActorContainerRef] '.' service=[SPP]
 		public Group getGroup() { return cGroup; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.50/@alternatives/@elements.0'
+		//ref=[ActorContainerRef]
 		public Assignment getRefAssignment_0() { return cRefAssignment_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.50/@alternatives/@elements.0/@terminal'
+		//[ActorContainerRef]
 		public CrossReference getRefActorContainerRefCrossReference_0_0() { return cRefActorContainerRefCrossReference_0_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.50/@alternatives/@elements.0/@terminal/@terminal'
+		//ID
 		public RuleCall getRefActorContainerRefIDTerminalRuleCall_0_0_1() { return cRefActorContainerRefIDTerminalRuleCall_0_0_1; }
 
 		//'.'
@@ -3057,10 +3161,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.etrice.core.Room.AbstractInterfaceItem");
 		private final RuleCall cInterfaceItemParserRuleCall = (RuleCall)rule.eContents().get(1);
 		
-		//// **************************************************************
-		//// concrete message and interface item for state machines
-		////AbstractMessage: Message;
-		//AbstractInterfaceItem:
+		//@ Override AbstractInterfaceItem:
 		//	InterfaceItem;
 		@Override public ParserRule getRule() { return rule; }
 
@@ -3117,7 +3218,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		private final Keyword cPortKeyword_7 = (Keyword)cAlternatives.eContents().get(7);
 		private final Keyword cMessageKeyword_8 = (Keyword)cAlternatives.eContents().get(8);
 		
-		//AnnotationTargetType:
+		//@ Override AnnotationTargetType:
 		//	'DataClass' |
 		//	'ActorClass' |
 		//	'ActorBehavior' |
@@ -3309,19 +3410,19 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//LOGICAL_SYSTEM_CLASS='LogicalSystem'
 		public EnumLiteralDeclaration getLOGICAL_SYSTEM_CLASSEnumLiteralDeclaration_6() { return cLOGICAL_SYSTEM_CLASSEnumLiteralDeclaration_6; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.56/@alternatives/@elements.6/@literal'
+		//'LogicalSystem'
 		public Keyword getLOGICAL_SYSTEM_CLASSLogicalSystemKeyword_6_0() { return cLOGICAL_SYSTEM_CLASSLogicalSystemKeyword_6_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.56/@alternatives/@elements.7'
+		//PORT='Port'
 		public EnumLiteralDeclaration getPORTEnumLiteralDeclaration_7() { return cPORTEnumLiteralDeclaration_7; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.56/@alternatives/@elements.7/@literal'
+		//'Port'
 		public Keyword getPORTPortKeyword_7_0() { return cPORTPortKeyword_7_0; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.56/@alternatives/@elements.8'
+		//MESSAGE='Message'
 		public EnumLiteralDeclaration getMESSAGEEnumLiteralDeclaration_8() { return cMESSAGEEnumLiteralDeclaration_8; }
 
-		//org.eclipse.xtext.resource.ClasspathUriResolutionException: org.eclipse.xtext.resource.FileNotFoundOnClasspathException: Couldn't find resource on classpath. URI was 'classpath:/org/eclipse/etrice/core/Room.xtext#/0/@rules.56/@alternatives/@elements.8/@literal'
+		//'Message'
 		public Keyword getMESSAGEMessageKeyword_8_0() { return cMESSAGEMessageKeyword_8_0; }
 	}
 	
@@ -3330,6 +3431,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	private final StructureClassElements pStructureClass;
 	private final ActorContainerClassElements pActorContainerClass;
 	private final VarDeclElements pVarDecl;
+	private final MessageDataElements pMessageData;
 	private final RefableTypeElements pRefableType;
 	private final DataTypeElements pDataType;
 	private final ComplexTypeElements pComplexType;
@@ -3405,6 +3507,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		this.pStructureClass = new StructureClassElements();
 		this.pActorContainerClass = new ActorContainerClassElements();
 		this.pVarDecl = new VarDeclElements();
+		this.pMessageData = new MessageDataElements();
 		this.pRefableType = new RefableTypeElements();
 		this.pDataType = new DataTypeElements();
 		this.pComplexType = new ComplexTypeElements();
@@ -3550,6 +3653,16 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		return getVarDeclAccess().getRule();
 	}
 
+	//MessageData:
+	//	(deprecatedName=ID ':')? refType=RefableType;
+	public MessageDataElements getMessageDataAccess() {
+		return pMessageData;
+	}
+	
+	public ParserRule getMessageDataRule() {
+		return getMessageDataAccess().getRule();
+	}
+
 	//RefableType:
 	//	type=[DataType|FQN] ref?='ref'?;
 	public RefableTypeElements getRefableTypeAccess() {
@@ -3755,7 +3868,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//Message:
-	//	priv?='private'? 'Message' name=ID '(' data=VarDecl? ')' annotations+=Annotation*
+	//	priv?='private'? 'Message' name=ID ('(' data=MessageData? ')')? annotations+=Annotation*
 	//	docu=Documentation?;
 	public MessageElements getMessageAccess() {
 		return pMessage;
@@ -3808,9 +3921,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		return getOutMessageHandlerAccess().getRule();
 	}
 
-	//// **************************************************************
-	//// actor class
-	//ModelComponent:
+	//@ Override ModelComponent:
 	//	ActorClass;
 	public ModelComponentElements getModelComponentAccess() {
 		return pModelComponent;
@@ -4091,10 +4202,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		return getReferenceTypeAccess().getRule();
 	}
 
-	//// **************************************************************
-	//// concrete message and interface item for state machines
-	////AbstractMessage: Message;
-	//AbstractInterfaceItem:
+	//@ Override AbstractInterfaceItem:
 	//	InterfaceItem;
 	public AbstractInterfaceItemElements getAbstractInterfaceItemAccess() {
 		return pAbstractInterfaceItem;
@@ -4118,7 +4226,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		return getMULTIPLICITYAccess().getRule();
 	}
 
-	//AnnotationTargetType:
+	//@ Override AnnotationTargetType:
 	//	'DataClass' |
 	//	'ActorClass' |
 	//	'ActorBehavior' |
@@ -4192,7 +4300,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//StateGraphItem:
-	//	StateGraphNode | Transition;
+	//	StateGraphNode | TransitionBase;
 	public FSMGrammarAccess.StateGraphItemElements getStateGraphItemAccess() {
 		return gaFSM.getStateGraphItemAccess();
 	}
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/Room.xtext b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/Room.xtext
index 9015bfd2d..ad2e02e8a 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/Room.xtext
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/Room.xtext
@@ -53,6 +53,9 @@ ActorContainerClass: ActorClass | SubSystemClass;
 VarDecl:
 	name=ID ':' refType=RefableType;
 
+MessageData:
+	(deprecatedName=ID ':')? refType=RefableType;
+
 RefableType: type=[DataType|FQN] (ref?='ref')?;
 
 DataType: PrimitiveType | EnumerationType | ComplexType;
@@ -143,7 +146,7 @@ CompoundProtocolClass:
 SubProtocol: 'SubProtocol' name=ID ':' protocol=[GeneralProtocolClass|FQN];
 
 Message:
-	(priv?='private')? 'Message' name=ID '(' (data=VarDecl)? ')' annotations+=Annotation*
+	(priv?='private')? 'Message' name=ID ( '(' (data=MessageData)? ')' )? annotations+=Annotation*
 	(docu=Documentation)?;
 
 PortClass:
@@ -172,6 +175,7 @@ OutMessageHandler:
 // **************************************************************
 // actor class
 
+@Override 
 ModelComponent: ActorClass;
 
 // some notes on ports
@@ -318,6 +322,7 @@ enum ReferenceType:
 // concrete message and interface item for state machines
 
 //AbstractMessage: Message;
+@Override 
 AbstractInterfaceItem: InterfaceItem;
 
 // **************************************************************
@@ -327,6 +332,7 @@ AbstractInterfaceItem: InterfaceItem;
 // (because then the lexer already would find this in places where it is not expected, e.g. in an Attribute)
 MULTIPLICITY returns ecore::EInt : '[' ('*'|INT) ']';
 
+@Override 
 AnnotationTargetType:
 	'DataClass' |
 	'ActorClass' |
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/RoomRuntimeModule.java b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/RoomRuntimeModule.java
index 37ac71a9b..734386656 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/RoomRuntimeModule.java
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/RoomRuntimeModule.java
@@ -15,9 +15,11 @@ package org.eclipse.etrice.core;
 import org.eclipse.etrice.core.common.scoping.ModelLocatorUriResolver;
 import org.eclipse.etrice.core.common.validation.CustomValidatorManager.StandaloneValidatorExtension;
 import org.eclipse.etrice.core.converter.RoomValueConverterService;
+import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator;
 import org.eclipse.etrice.core.linking.RoomConvertingLazyLinker;
 import org.eclipse.etrice.core.naming.RoomFragmentProvider;
 import org.eclipse.etrice.core.naming.RoomQualifiedNameProvider;
+import org.eclipse.etrice.core.room.util.CommonDataCalculator;
 import org.eclipse.etrice.core.validation.FQNAreUniqueValidationHelper;
 import org.eclipse.etrice.core.validation.ValidatorExtensionManager;
 import org.eclipse.xtext.conversion.IValueConverterService;
@@ -98,5 +100,8 @@ public class RoomRuntimeModule extends org.eclipse.etrice.core.AbstractRoomRunti
 	public Class<? extends INamesAreUniqueValidationHelper> bindINamesAreUniqueValidationHelper(){
 		return FQNAreUniqueValidationHelper.class;
 	}
-
+	
+    public Class<? extends ICommonDataCalculator> bindICommonDataCalculator() {
+        return CommonDataCalculator.class;
+    }
 }
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/naming/RoomFragmentProvider.java b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/naming/RoomFragmentProvider.java
index 0dcda3a25..68d05abc2 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/naming/RoomFragmentProvider.java
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/naming/RoomFragmentProvider.java
@@ -123,7 +123,12 @@ public class RoomFragmentProvider extends FSMFragmentProvider {
 		}
 
 		private String caseSPPointShort(SPPoint sppt) {
-			return sppt.getRef().getName()+EP_SEP+sppt.getService().getName();
+			if(sppt == null || (sppt.getRef() == null && sppt.getService() == null))
+				return "null";
+			String ref = (sppt.getRef() == null) ? "null" : sppt.getRef().getName();
+			String service = (sppt.getService() == null) ? "null" : sppt.getService().getName();
+			
+			return ref+EP_SEP+service;
 		}
 	}
 
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/postprocessing/ImplPostprocessor.xtend b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/postprocessing/ImplPostprocessor.xtend
index 34f368576..30a6a879c 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/postprocessing/ImplPostprocessor.xtend
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/postprocessing/ImplPostprocessor.xtend
@@ -72,7 +72,8 @@ class ImplPostprocessor {
 			'''
 				EList<Port> ports = new BasicEList<Port>();
 				for (ExternalPort ep : getExternalPorts()) {
-					ports.add(ep.getInterfacePort());
+					if(ep.getInterfacePort() != null)
+						ports.add(ep.getInterfacePort());
 				}
 				return ports;
 			'''
@@ -81,7 +82,8 @@ class ImplPostprocessor {
 			'''
 				EList<Port> ports = new BasicEList<Port>(getInterfacePorts());
 				for (ExternalPort ep : getExternalPorts()) {
-					ports.remove(ep.getInterfacePort());
+					if(ep.getInterfacePort() != null)
+						ports.remove(ep.getInterfacePort());
 				}
 				return ports;
 			'''
@@ -90,7 +92,8 @@ class ImplPostprocessor {
 			'''
 				EList<SPP> spps = new BasicEList<SPP>();
 				for (ServiceImplementation spp : getServiceImplementations()) {
-					spps.add(spp.getSpp());
+					if(spp.getSpp() != null)
+						spps.add(spp.getSpp());
 				}
 				return spps;
 			'''
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/CommonDataCalculator.xtend b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/CommonDataCalculator.xtend
new file mode 100644
index 000000000..c40a8dc8a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/CommonDataCalculator.xtend
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.room.util
+
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.RoomFactory
+
+class CommonDataCalculator implements ICommonDataCalculator {
+	
+	RoomHelpers roomHelpers = new RoomHelpers
+	
+	// TODO 529445: return a RefableType, not MessageData
+	override EObject calculateCommonData(Link l) {
+		if (!l.isIfitemTriggered) {
+			return null
+		}
+		else {
+			// since l isIfitemTriggered we have at least one triggered transition
+			var transitions = l.chainHeads.map[transition.realTransition].filter(typeof(TriggeredTransition))
+			
+			// we also expect to have triggers
+			val triggers = transitions.map[triggers].flatten
+			
+			// and we have data which may be null
+			val varDeclarations = triggers.map[msgFromIfPairs].flatten.map[message].filter(Message).map[data]
+			val allData = varDeclarations.map[it?.refType?.type].toSet
+			if (allData.size==1) {
+				return varDeclarations.head
+			}
+			else {
+				val types = varDeclarations.map[it?.refType].toList
+				val rt = roomHelpers.getLastCommonSuperType(types);
+				if (rt!==null) {
+					// artificial variable declaration
+					val vd = RoomFactory.eINSTANCE.createMessageData
+					vd.deprecatedName = "data"
+					vd.refType = rt
+					return vd
+				}
+			}
+		}
+		
+		return null
+	}
+	
+	private static def realTransition(TransitionBase t) {
+		var tr = t
+		while (tr instanceof RefinedTransition) {
+			tr = tr.target
+		}
+		
+		return tr
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/RoomHelpers.java b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/RoomHelpers.java
index 770eb4344..c8b5bef12 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/RoomHelpers.java
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/RoomHelpers.java
@@ -1322,6 +1322,10 @@ public class RoomHelpers extends FSMHelpers {
 	 * @return the last common super type of a list of types or <code>null</code> if no such exists
 	 */
 	public RefableType getLastCommonSuperType(List<RefableType> types) {
+		if (types.isEmpty()) {
+			return null;
+		}
+		
 		int nref = 0;
 		int ndc = 0;
 		for (RefableType rt : types) {
diff --git a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/validation/RoomJavaValidator.java b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/validation/RoomJavaValidator.java
index 0d5c04a5e..9329602ce 100644
--- a/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/validation/RoomJavaValidator.java
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/validation/RoomJavaValidator.java
@@ -53,6 +53,7 @@ import org.eclipse.etrice.core.room.InterfaceItem;
 import org.eclipse.etrice.core.room.LayerConnection;
 import org.eclipse.etrice.core.room.LogicalSystem;
 import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageData;
 import org.eclipse.etrice.core.room.Operation;
 import org.eclipse.etrice.core.room.Port;
 import org.eclipse.etrice.core.room.PortClass;
@@ -102,16 +103,17 @@ public class RoomJavaValidator extends AbstractRoomJavaValidator {
 	/* tags for quick fixes */
 	public static final String THREAD_MISSING = "RoomJavaValidator.ThreadMissing";
 	public static final String DUPLICATE_ACTOR_INSTANCE_MAPPING = "RoomJavaValidator.DuplicateActorInstanceMapping";
+	public static final String WRONG_NAMESPACE = "RoomJavaValidator.WrongNamespace";
 	public static final String CIRCULAR_CONTAINMENT = "RoomJavaValidator.CircularContainment";
 	public static final String ACTOR_REF_CHANGE_REF_TYPE_TO_FIXED_OR_MULT_TO_ANY = "RoomJavaValidator.ActorRefChangeRefTypeToFixed";
 	public static final String ACTOR_REF_CHANGE_REF_TYPE_TO_OPTIONAL = "RoomJavaValidator.ActorRefChangeRefTypeToOptional";
-	public static final String WRONG_NAMESPACE = "RoomJavaValidator.WrongNamespace";
 	public static final String CHANGE_DESTRUCTOR_NAME = "RoomJavaValidator.ChangeDestructorName";
 	public static final String CHANGE_CONSTRUCTOR_NAME = "RoomJavaValidator.ChangeConstructorName";
 	public static final String INVALID_ANNOTATION_TARGET = "RoomJavaValidator.InvalidAnnotationTarget";
 	public static final String OPERATION_MISSING_OVERRIDE = "RoomJavaValidator.OperationMissingOverride";
 	public static final String OPERATION_EXTRANEOUS_OVERRIDE = "RoomJavaValidator.OperationExtraneousOverride";
-	public static final String INCONSISTENT_COMMUNICATION_TYPE = "RoomJavaValidator.InconsistentCommType";	
+	public static final String INCONSISTENT_COMMUNICATION_TYPE = "RoomJavaValidator.InconsistentCommType";
+	public static final String DEPRECATED_MESSAGE_DATA_NAME = "RoomJavaValidator.DeprecatedMessageDataName";
 
 	@Check
 	public void checkRoomImportedNamespace(Import imp) {
@@ -163,7 +165,6 @@ public class RoomJavaValidator extends AbstractRoomJavaValidator {
 			error("referenced model is not supported", BasePackage.Literals.IMPORT__IMPORTED_NAMESPACE, WRONG_NAMESPACE, candidatesNames.toArray(new String[0]));
 	}
 	
-
 	@Check
 	public void checkActorRef(ActorRef ar) {
 		if (ar.eContainer() instanceof ActorClass) {
@@ -199,7 +200,7 @@ public class RoomJavaValidator extends AbstractRoomJavaValidator {
 			if (ar.getMultiplicity()>1) {
 				for (Port p : ac.getInterfacePorts()) {
 					if (p.getMultiplicity()<0) {
-						int idx = ((ActorContainerClass)ar.eContainer()).getActorRefs().indexOf(ar);
+						//int idx = ((ActorContainerClass)ar.eContainer()).getActorRefs().indexOf(ar);
 						error("replicated actor must not have replicated port with arbitrary multiplicity", null);
 					}
 				}
@@ -618,9 +619,12 @@ public class RoomJavaValidator extends AbstractRoomJavaValidator {
 
 	@Check
 	public void checkMessageFromIf(MessageFromIf mfi){
-		if(mfi.getFrom() != null){
-			if(roomHelpers.getProtocol((InterfaceItem)mfi.getFrom()).getCommType() != CommunicationType.EVENT_DRIVEN)
-				error("port must have event driven protocol", mfi, FSMPackage.eINSTANCE.getMessageFromIf_From());
+		if (mfi.getFrom() != null){
+			ProtocolClass protocol = roomHelpers.getProtocol((InterfaceItem)mfi.getFrom());
+			if (protocol!=null && !protocol.eIsProxy()) {
+				if (protocol.getCommType() != CommunicationType.EVENT_DRIVEN)
+					error("port must have event driven protocol", mfi, FSMPackage.eINSTANCE.getMessageFromIf_From());
+			}
 		}
 	}
 
@@ -799,4 +803,11 @@ public class RoomJavaValidator extends AbstractRoomJavaValidator {
 				error("Return type  must be identical to overriden operation " +baseOpFQN, op, RoomPackage.Literals.OPERATION__RETURN_TYPE);
 		}
 	}
+	
+	@Check
+	public void checkMessageData(MessageData m) {
+		if (m.getDeprecatedName()!=null) {
+			warning("The data name of messages is deprecated (always named 'transitionData' in action code)", RoomPackage.Literals.MESSAGE_DATA__DEPRECATED_NAME, DEPRECATED_MESSAGE_DATA_NAME);
+		}
+	}
 }
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/.classpath b/plugins/org.eclipse.etrice.dctools.fsm/.classpath
new file mode 100644
index 000000000..428337e56
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="xtend-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/.gitignore b/plugins/org.eclipse.etrice.dctools.fsm/.gitignore
new file mode 100644
index 000000000..1a7726dc2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/.gitignore
@@ -0,0 +1,4 @@
+bin
+*._trace
+*.smap
+*.xtendbin
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/.project b/plugins/org.eclipse.etrice.dctools.fsm/.project
new file mode 100644
index 000000000..8fe3f91ab
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.etrice.dctools.fsm</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.dctools.fsm/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.dctools.fsm/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..b06c4dba8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/META-INF/MANIFEST.MF
@@ -0,0 +1,21 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Detail Code Tools for FSM
+Bundle-SymbolicName: org.eclipse.etrice.dctools.fsm
+Bundle-Version: 1.1.3.qualifier
+Automatic-Module-Name: org.eclipse.etrice.dctools.fsm
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-Vendor: Eclipse eTrice
+Require-Bundle: org.eclipse.jface.text,
+ org.eclipse.xtext.xbase.lib;bundle-version="2.6.0",
+ org.eclipse.xtend.lib;bundle-version="2.6.0",
+ org.eclipse.xtend.lib.macro;bundle-version="2.6.0",
+ org.eclipse.xtext.ui,
+ org.eclipse.etrice.core.fsm,
+ org.eclipse.etrice.generator
+Export-Package: org.eclipse.etrice.dctools.fsm.ast,
+ org.eclipse.etrice.dctools.fsm.ast.internal;x-friends:="org.eclipse.etrice.dctools.tests",
+ org.eclipse.etrice.dctools.fsm.ast.nodes,
+ org.eclipse.etrice.dctools.fsm.ast.tokens,
+ org.eclipse.etrice.dctools.fsm.ast.util
+
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/build.properties b/plugins/org.eclipse.etrice.dctools.fsm/build.properties
new file mode 100644
index 000000000..d8e2f0e92
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\
+           xtend-gen/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/CandidateMap.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/CandidateMap.xtend
new file mode 100644
index 000000000..9251fd45b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/CandidateMap.xtend
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+import java.util.HashMap
+import org.eclipse.emf.ecore.EObject
+
+class CandidateMap extends HashMap<String, EObject> {
+	
+	def CandidateMap getMatches(String prefix) {
+		val result = new CandidateMap
+		
+		for (entry : entrySet) {
+			if (entry.key.startsWith(prefix)) {
+				result.put(entry.key, entry.value)
+			}
+		}
+		
+		return result
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCLanguage.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCLanguage.xtend
new file mode 100644
index 000000000..c02887dbf
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCLanguage.xtend
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+enum DCLanguage {
+	C_LANGUAGE,
+	CPP_LANGUAGE,
+	JAVA_LANGUAGE,
+	OTHER_LANGUAGE
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCNodeAtOffset.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCNodeAtOffset.xtend
new file mode 100644
index 000000000..d59d0bc8e
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCNodeAtOffset.xtend
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+import org.eclipse.etrice.dctools.fsm.ast.util.IDCAstNodeVisitor
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstMatchNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstTextNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode
+
+class DCNodeAtOffset implements IDCAstNodeVisitor {
+	
+	int offset
+	DCAstTextNode result = null
+	
+	private new (int offset) {
+		this.offset = offset
+	}
+	
+	static def find(DCAstMatchNode ast, int offset) {
+		val visitor = new DCNodeAtOffset(offset)
+		ast.visit(visitor)
+		return visitor.result
+	}
+	
+	override visitBegin(DCAstNode node) {
+		if (result===null) {
+			if (node instanceof DCAstTextNode) {
+				if (node.begin<=offset && offset<node.end) {
+					result = node
+				}
+			}
+			if (node instanceof DCAstBracketNode) {
+				// also test the closing bracket
+				if (node.posClose>=0) {
+					if (node.posClose==offset) {
+						result = node
+					}
+				}
+			}
+		}
+		return result===null
+	}
+	
+	override visitEnd(DCAstNode node) {
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCParser.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCParser.xtend
new file mode 100644
index 000000000..0a190c8d4
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCParser.xtend
@@ -0,0 +1,367 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+import java.util.ArrayList
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstArrayAccessNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode.BracketType
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstFeatureCallNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierBracketNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstMatchNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOperationCallNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOtherNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstPeriodNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstWhitespaceNode
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCBracketToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCBracketToken.BracketKind
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCTextToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken.Kind
+
+/**
+ * 
+ * Grammar:
+ * 
+ * PartialMatch: BracketExpression | FeatureCall
+ * 
+ * BracketExpression: RoundBracketExpression | CurlyBracketExpression | SquareBracketExpression
+ * RoundBracketExpression: LEFT_ROUNDBRACKET Match RIGHT_ROUNDBRACKET
+ * CurlyBracketExpression: LEFT_CURLYBRACKET Match RIGHT_CORLYBRACKET
+ * SquareBracketExpression: LEFT_SQUAREBRACKET Match RIGHT_SQUAREBRACKET
+ * 
+ * FeatureCall: Call Whitespace (PERIOD Whitespace Call Whitespace)*
+ * Call: ArrayAccess | OperationCall | IDENTIFIER
+ * ArrayAccess: IDENTIFIER Whitespace SquareBracketExpression
+ * OperationCall: IDENTIFIER Whitespace RoundBracketExpression
+ * 
+ * Whitespace: WHITESPACE*
+ * 
+ * Match: (PartialMatch* Other)*
+ * 
+ * Other: *
+ */
+class DCParser {
+	
+	val DCScanner scanner
+	String text
+	ArrayList<DCTextToken> tokens
+	int currentPosition = 0
+	
+	new(DCLanguage language) {
+		scanner = new DCScanner(language)
+	}
+	
+	def parse(String text) {
+		this.text = text
+		this.tokens = scanner.scan(text)
+		
+		Match(null)
+	}
+	
+	/*
+	 * rules
+	 */
+	private def DCAstMatchNode Match(DCAstNode parent) {
+		val mNode = new DCAstMatchNode(parent)
+		
+		var continue = true
+		while (continue) {
+			while (PartialMatch(mNode)!==null) {}
+			if (Other(mNode)===null) {
+				continue = false
+			}
+		}
+		
+		return mNode
+	}
+	
+	private def DCAstOtherNode Other(DCAstNode parent) {
+		var DCAstOtherNode lastNode = null
+		var token = read
+		
+		if (token!==null) {
+			while (token!==null) {
+				if (stopOther(token)) {
+					unread
+					token = null
+				}
+				else {
+					// we consumed a token
+					lastNode = new DCAstOtherNode(parent, text.substring(token.begin, token.begin + token.length), token)
+					
+					// do we have a partial match after that token?
+					val pNode = PartialMatch(null)
+					if (pNode!==null) {
+						unread(pNode)
+						token = null
+					}
+					else {
+						token = read
+					}
+				}
+			}
+		}
+		
+		return lastNode
+	}
+	
+	private def boolean stopOther(DCTextToken token) {
+		if (token.token instanceof DCBracketToken) {
+			return true
+		}
+		if (token.token.kind==Kind.IDENTIFIER) {
+			return true
+		}
+		return false
+	}
+	
+	private def DCAstNode PartialMatch(DCAstNode parent) {
+		var node = ConcreteBracketExpression(parent) as DCAstNode
+		if (node===null) {
+			node = FeatureCall(parent)
+		}
+		return node
+	}
+	
+	private def DCAstBracketNode ConcreteBracketExpression(DCAstNode parent) {
+		var node = RoundBracketExpression(parent)
+		if (node===null) {
+			node = CurlyBracketExpression(parent)
+		}
+		if (node===null) {
+			node = SquareBracketExpression(parent)
+		}
+		return node
+	}
+	
+	private def DCAstBracketNode RoundBracketExpression(DCAstNode parent) {
+		return ConcreteBracketExpression(parent, BracketKind.LEFT_ROUND, BracketKind.RIGHT_ROUND, BracketType.ROUND)
+	}
+	
+	private def DCAstBracketNode CurlyBracketExpression(DCAstNode parent) {
+		return ConcreteBracketExpression(parent, BracketKind.LEFT_CURLY, BracketKind.RIGHT_CURLY, BracketType.CURLY)
+	}
+	
+	private def DCAstBracketNode SquareBracketExpression(DCAstNode parent) {
+		return ConcreteBracketExpression(parent, BracketKind.LEFT_SQUARE, BracketKind.RIGHT_SQUARE, BracketType.SQUARE)
+	}
+	
+	private def DCAstBracketNode ConcreteBracketExpression(DCAstNode parent, BracketKind left, BracketKind right, BracketType type) {
+		var token = read
+		
+		if (token!==null) {
+			if (token.token instanceof DCBracketToken) {
+				var b = token.token as DCBracketToken
+				if (b.bracketKind==left) {
+					val contents = Match(parent)
+					val leftPos = token.begin
+					token = read
+					if (token!==null) {
+						if (token.token instanceof DCBracketToken) {
+							val rightPos = token.begin
+							b = token.token as DCBracketToken
+							if (b.bracketKind==right) {
+								return new DCAstBracketNode(parent, type, contents, leftPos, rightPos)
+							}
+						}
+						unread // second token
+					}
+					else {
+						// we reached the end without a matching right bracket
+						return new DCAstBracketNode(parent, type, contents, leftPos)
+					}
+					unread(contents)
+				}
+			}
+			unread // first token
+		}
+		
+		return null
+	}
+	
+	private def DCAstFeatureCallNode FeatureCall(DCAstNode parent) {
+		val callNode = Call(parent)
+		
+		if (callNode!==null) {
+			val fcNode = new DCAstFeatureCallNode(parent)
+			callNode.parent = fcNode
+			
+			// optional whitespace
+			Whitespace(fcNode)
+			
+			// (PERIOD Whitespace Call)*
+			var token = read
+			while (token!==null) {
+				if (token.token.kind==Kind.PERIOD) {
+					val pNode = new DCAstPeriodNode(null, token.begin)
+					val wsNode = Whitespace(null)
+					val cNode = Call(null)
+					val wsNode2 = Whitespace(null)
+					if (pNode!==null) {
+						pNode.parent = fcNode
+						if (wsNode!==null) {
+							wsNode.parent = fcNode
+						}
+						if (cNode!==null) {
+							cNode.parent = fcNode
+						} 
+						if (wsNode2!==null) {
+							wsNode2.parent = fcNode
+						}
+						
+						if (cNode!==null) {
+							// next token
+							token = read
+						}
+						else {
+							token = null
+						}
+					}
+					else {
+						unread(pNode)
+						unread(wsNode)
+						unread(pNode)
+						unread(wsNode2)
+						unread // the token itself
+						token = null
+					}
+				}
+				else {
+					unread // the token itself
+					token = null
+				}
+			}
+			
+			return fcNode
+		}
+		
+		unread(callNode)
+		
+		return null
+	}
+	
+	private def DCAstNode Call(DCAstNode parent) {
+		// try ArrayAccess
+		var node = BracketExpressionCall(parent, [SquareBracketExpression], [p, i, w, b| new DCAstArrayAccessNode(p, i, w, b)])
+		if (node===null) {
+			// try OperationCall
+			node = BracketExpressionCall(parent, [RoundBracketExpression], [p, i, w, b| new DCAstOperationCallNode(p, i, w, b)])
+		}
+		if (node!==null) {
+			return node
+		}
+		else {
+			// try IDENTIFIER
+			val token = read
+			if (token!==null) {
+				if (token.token.kind==Kind.IDENTIFIER) {
+					val id = text.substring(token.begin, token.begin + token.length)
+					return new DCAstIdentifierNode(parent, id, token)
+				}
+				unread
+			}
+		}
+		return null
+	}
+	
+	private def DCAstIdentifierBracketNode BracketExpressionCall(
+		DCAstNode parent,
+		(DCAstNode)=>DCAstBracketNode bracketExpression,
+		(DCAstNode, DCAstIdentifierNode, DCAstWhitespaceNode, DCAstBracketNode)=>DCAstIdentifierBracketNode factory
+	) {
+		val token = read
+		if (token!==null) {
+			if (token.token.kind==Kind.IDENTIFIER) {
+				// first child is ID
+				val id = text.substring(token.begin, token.begin + token.length)
+				val idNode = new DCAstIdentifierNode(parent, id, token)
+				
+				// optional whitespace
+				val wsNode = Whitespace(parent)
+				
+				// second child is BracketExpression
+				val node = bracketExpression.apply(parent)
+				if (node!==null) {
+					// the node of the bracket expression call
+					val callNode = factory.apply(parent, idNode, wsNode, node)
+					return callNode
+				}
+				
+				unread(idNode)
+				unread(wsNode)
+			}
+			else {
+				unread
+			}
+		}
+		
+		return null
+	}
+	
+	private def DCAstWhitespaceNode Whitespace(DCAstNode parent) {
+		var token = read
+		val begin = if (token!==null) token.begin else 0
+		var int end = 0
+		var count = 0
+		while (token!==null) {
+			if (token.token.kind==Kind.WHITESPACE) {
+				end = token.begin + token.length
+				count++
+				token = read
+			}
+			else {
+				token = null
+				unread
+			}
+		}
+		
+		if (count>0) {
+			val ws = text.substring(begin, end)
+			return new DCAstWhitespaceNode(parent, count, begin, ws)
+		}
+		
+		return null
+	}
+	
+	/*
+	 * helpers
+	 */
+	private def DCTextToken read() {
+		if (currentPosition<tokens.size) {
+			tokens.get(currentPosition++)
+		}
+		else {
+			null
+		}
+	}
+	
+	private def void unread() {
+		unread(1)
+	}
+	
+	private def void unread(int i) {
+		currentPosition = currentPosition - i
+		if (currentPosition<0) {
+			println("oops")
+		}
+	}
+	
+	private def void unread(DCAstNode node) {
+		if (node!==null) {
+			node.parent = null
+			unread(node.totallyReadTokens)
+		}
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCScanner.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCScanner.xtend
new file mode 100644
index 000000000..1ae4813f7
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/DCScanner.xtend
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+import com.google.common.collect.Iterables
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCBracketRule
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCIdentifierRule
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCKeywordRule
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCSpecialCharRule
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCWhitespaceDetector
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCTextToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken.Kind
+import org.eclipse.jface.text.Document
+import org.eclipse.jface.text.rules.EndOfLineRule
+import org.eclipse.jface.text.rules.IRule
+import org.eclipse.jface.text.rules.IToken
+import org.eclipse.jface.text.rules.MultiLineRule
+import org.eclipse.jface.text.rules.NumberRule
+import org.eclipse.jface.text.rules.RuleBasedScanner
+import org.eclipse.jface.text.rules.SingleLineRule
+import org.eclipse.jface.text.rules.Token
+import org.eclipse.jface.text.rules.WhitespaceRule
+
+class DCScanner {
+	
+	val RuleBasedScanner scanner = new RuleBasedScanner
+	DCLanguage language
+	
+	new(DCLanguage language) {
+		this.language = language
+		
+		// initialize scanner with rules
+		scanner.rules = rules
+	}
+	
+	def scan(String text) {
+		val result = newArrayList
+		
+		scanner.setRange(new Document(text), 0, text.length())
+		
+		var IToken lastToken = null 
+		while (lastToken !== Token.EOF) {
+			lastToken = scanner.nextToken() 
+			if (lastToken !== null) {
+				val begin = scanner.tokenOffset
+				val end = begin + scanner.tokenLength
+				if (begin >= 0 && begin < end) {
+					if (lastToken instanceof DCToken) {
+						result.add(new DCTextToken(begin, scanner.tokenLength, lastToken))
+					}
+					else {
+						result.add(new DCTextToken(begin, scanner.tokenLength, new DCToken(Kind.OTHER)))
+					}
+				}
+			}
+		}
+		
+		return result
+	}
+	
+	private def getRules() {
+		val rules = newArrayList
+		
+		// rules for comments (also unclosed C-comments)
+		rules.add(new EndOfLineRule("//", new DCToken(Kind.COMMENT)))
+		rules.add(new MultiLineRule("/*", "*/", new DCToken(Kind.COMMENT), 0 as char, true))
+		
+		// rules for strings
+		rules.add(new SingleLineRule("\"", "\"", new DCToken(Kind.STRING), '\\'))
+		rules.add(new SingleLineRule("'", "'", new DCToken(Kind.STRING), '\\'))
+		// multiline or unclosed strings (which may occur during editing)
+		rules.add(new MultiLineRule("\"", "\"", new DCToken(Kind.STRING), '\\', true))
+		rules.add(new MultiLineRule("'", "'", new DCToken(Kind.STRING), '\\', true))
+		
+		// keywords, numbers and IDs
+		rules.add(new NumberRule(new DCToken(Kind.NUMBER)))
+		if (language!==DCLanguage.OTHER_LANGUAGE) {
+			rules.add(new DCKeywordRule(language))
+		}
+		rules.add(new DCIdentifierRule)
+		
+		// whitespace, brackets and special characters
+		rules.add(new WhitespaceRule(new DCWhitespaceDetector, new DCToken(Kind.WHITESPACE)))
+		rules.add(new DCBracketRule)
+		rules.add(new DCSpecialCharRule)
+		
+		Iterables.toArray(rules, IRule)
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/IFSMTranslationProvider.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/IFSMTranslationProvider.xtend
new file mode 100644
index 000000000..89de4130d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/IFSMTranslationProvider.xtend
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast
+
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+
+/**
+ * @author Henrik Rentz-Reichert
+ *
+ */
+interface IFSMTranslationProvider {
+	
+	/** 
+	 * start sequence for tags to be translated
+	 */
+	public static final String TAG_START="<|"
+	
+	/** 
+	 * end sequence for tags to be translated
+	 */
+	public static final String TAG_END="|>"
+	
+	/** 
+	 * the container class for which translations have to be provided.
+	 * This can be either of
+	 * <ul>
+	 * <li>{@link ModelComponent}</li>
+	 * <li>DataClass</li>
+	 * <li>ProtocolClass</li>
+	 * <li>PortClass</li>
+	 * </ul>
+	 * @param container
+	 */
+	def void setContainerClass(EObject container) 
+	
+	/** 
+	 * @return true if translation should be applied to members (attributes, operations and port.msg)
+	 */
+	def boolean translateMembers() 
+	
+	/** 
+	 * yield a sequence that sends a message through an interface item (port or SAP).
+	 * Is called whenever <i>port</i>.<i>msg</i>(<i>args</i>)
+	 * or <i>port</i>[<i>index</i>].<i>msg</i>(<i>args</i>) is found in the detail code
+	 * @param item the interface item
+	 * @param msg the message to send
+	 * @param ifitem the pointer of the interface item
+	 * @param args the message parameters
+	 * @param index array index for replicated ports, should be null for simple ports
+	 * and may be null for broadcast through replicated port
+	 * @param orig the original text
+	 * @return the translation
+	 */
+	def String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject msg, String ifitem, String args, String index, String orig) 
+	
+	/** 
+	 * @return true if translations are provided for tags
+	 */
+	def boolean translateTags() 
+	
+	/** 
+	 * yield a replacement for a tag. Is called whenever &lt;|<i>tag</i>|>
+	 * is found in the detail code
+	 * @param tag the tag name
+	 * @param code the detail code containing the tag
+	 * @return the translated tag
+	 */
+	def String translateTag(String tag, DetailCode code) 
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCBracketRule.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCBracketRule.xtend
new file mode 100644
index 000000000..6035f0d5a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCBracketRule.xtend
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.jface.text.rules.IRule
+import org.eclipse.jface.text.rules.ICharacterScanner
+import org.eclipse.jface.text.rules.Token
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCBracketToken
+
+class DCBracketRule implements IRule {
+	
+	override evaluate(ICharacterScanner scanner) {
+		val c = scanner.read
+		val token = DCBracketToken.getToken(c as char)
+		if (token!==null) {
+			return token
+		}
+		
+		scanner.unread
+		return Token.UNDEFINED
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCIdentifierRule.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCIdentifierRule.xtend
new file mode 100644
index 000000000..a81db6e80
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCIdentifierRule.xtend
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken.Kind
+import org.eclipse.jface.text.rules.ICharacterScanner
+import org.eclipse.jface.text.rules.IRule
+import org.eclipse.jface.text.rules.Token
+
+class DCIdentifierRule implements IRule {
+	
+	val detector = new DCWordDetector
+	val token = new DCToken(Kind.IDENTIFIER)
+	val buffer= new StringBuffer
+	
+	override evaluate(ICharacterScanner scanner) {
+		buffer.setLength(0)
+		
+		var c = scanner.read
+		if (c != ICharacterScanner.EOF && detector.isWordStart(c as char)) {
+			do {
+				buffer.append(c as char)
+				c = scanner.read()
+			}
+			while (c != ICharacterScanner.EOF && detector.isWordPart(c as char))
+			scanner.unread
+
+			val id = buffer.toString
+			if (!id.empty) {
+				return token
+			}
+		}
+		else {
+			scanner.unread
+		}
+		
+		for (var i= buffer.length() - 1; i >= 0; i--) {
+			scanner.unread
+		}
+		return Token.UNDEFINED
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywordRule.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywordRule.xtend
new file mode 100644
index 000000000..9dbef0a20
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywordRule.xtend
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.etrice.dctools.fsm.ast.DCLanguage
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken.Kind
+import org.eclipse.jface.text.rules.WordRule
+
+class DCKeywordRule extends WordRule {
+	
+	val keywordToken = new DCToken(Kind.KEYWORD)
+	
+	new(DCLanguage language) {
+		super(new DCWordDetector(language.isCFamily))
+		
+		switch language {
+			case C_LANGUAGE: DCKeywords.CKeywords.forEach[addWord(keywordToken)]
+			case CPP_LANGUAGE: DCKeywords.cppKeywords.forEach[addWord(keywordToken)]
+			case JAVA_LANGUAGE: DCKeywords.javaKeywords.forEach[addWord(keywordToken)]
+			default: {
+				// ignore
+			}
+		}
+	}
+	
+	static def isCFamily(DCLanguage language) {
+		language==DCLanguage.C_LANGUAGE || language==DCLanguage.CPP_LANGUAGE
+	}
+}
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywords.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywords.xtend
new file mode 100644
index 000000000..259006b0b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCKeywords.xtend
@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+class DCKeywords {
+	
+	static String[] cKeywords=#[
+		"const",
+		"unsigned",
+		"sizeof",
+		"typedef",
+		"virtual",
+		"struct",
+		"union",
+		"sizeof",
+		"explicit",
+		"export",
+		"extern",
+		"goto",
+		"register",
+		
+		// preprocessor
+		"#include",
+		"#define",
+		"#ifdef",
+		"#endif",
+		"#if",
+		"#else",
+		"#ifndef",
+		"#undef",
+		"#pragma"
+	]
+	static String[] cppKeywords=#[
+		"mutable",
+		"friend",
+		"inline",
+		"typeid",
+		"typename",
+		"namespace",
+		"class",
+		"using",
+		"template",
+		"this",
+		
+		// exceptions
+		"throw",
+		"try",
+		"catch",
+		"new",
+		"delete",
+		
+		// visibility
+		"public",
+		"private",
+		"protected"
+	]
+	static String[] javaKeywords=#[
+		"class",
+		"interface",
+		"extends",
+		"implements",
+		"abstract",
+		"this",
+		"new",
+		
+		// visibility
+		"public",
+		"private",
+		"protected",
+
+		// exceptions
+		"throw",
+		"try",
+		"catch",
+		"final",
+		"finally"
+	]
+	static String[] commonKeywords=#[
+		// flow control
+		"while",
+		"do",
+		"for",
+		"if",
+		"else",
+		"break",
+		"continue",
+		"switch",
+		"case",
+		"default",
+		"static",
+		"return",
+		
+		"volatile",
+		
+		// types
+		"void",
+		"int",
+		"float",
+		"double",
+		"short",
+		"char",
+		"long",
+		"signed",
+		
+		// literals
+		"true",
+		"false"
+	]
+	
+	static def getCKeywords() {
+		(commonKeywords + cKeywords).toList
+	}
+	
+	static def getCppKeywords() {
+		(commonKeywords + cKeywords + cppKeywords).toList
+	}
+	
+	static def getJavaKeywords() {
+		(commonKeywords + javaKeywords).toList
+	}
+}
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCSpecialCharRule.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCSpecialCharRule.xtend
new file mode 100644
index 000000000..2169be9e8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCSpecialCharRule.xtend
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCToken.Kind
+import org.eclipse.jface.text.rules.ICharacterScanner
+import org.eclipse.jface.text.rules.IRule
+import org.eclipse.jface.text.rules.Token
+
+class DCSpecialCharRule implements IRule {
+	
+	public static val char SEP = ';'
+	public static val char PERIOD = '.'
+	
+	val period = new DCToken(Kind.PERIOD)
+	val sep = new DCToken(Kind.STATEMENT_SEP)
+	
+	override evaluate(ICharacterScanner scanner) {
+		val c = scanner.read as char
+		
+		// Note: switch/case didn't work
+		if (c==SEP) {
+			sep
+		}
+		else if (c==PERIOD) {
+			period
+		}
+		else {
+			scanner.unread
+			Token.UNDEFINED
+		}
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWhitespaceDetector.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWhitespaceDetector.xtend
new file mode 100644
index 000000000..a3c3218d5
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWhitespaceDetector.xtend
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.jface.text.rules.IWhitespaceDetector
+
+class DCWhitespaceDetector implements IWhitespaceDetector {
+	
+	override isWhitespace(char c) {
+		Character.isWhitespace(c)
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWordDetector.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWordDetector.xtend
new file mode 100644
index 000000000..96b7165bf
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/internal/DCWordDetector.xtend
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.internal
+
+import org.eclipse.jface.text.rules.IWordDetector
+
+class DCWordDetector implements IWordDetector {
+
+	boolean includePreprocessDirectives
+	
+	new() {
+		this(false)
+	}
+	
+	new(boolean includePreprocessDirectives) {
+		this.includePreprocessDirectives = includePreprocessDirectives
+	}
+	
+	override boolean isWordStart(char c) {
+		Character.isJavaIdentifierStart(c) || (includePreprocessDirectives && c === Character.valueOf('#').charValue) 
+	}
+	override boolean isWordPart(char c) {
+		Character.isJavaIdentifierPart(c) 
+	}	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstArrayAccessNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstArrayAccessNode.xtend
new file mode 100644
index 000000000..f27463309
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstArrayAccessNode.xtend
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierBracketNode
+
+class DCAstArrayAccessNode extends DCAstIdentifierBracketNode {
+	
+	new(DCAstNode parent, DCAstIdentifierNode id, DCAstWhitespaceNode ws, DCAstBracketNode bracket) {
+		super(parent, id, ws, bracket)
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstArrayAccessNode '" + id + ws + bracket + "'" + linkedObjectText)
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstBracketNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstBracketNode.xtend
new file mode 100644
index 000000000..660f8f632
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstBracketNode.xtend
@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.xtend.lib.annotations.Accessors
+
+@Accessors
+class DCAstBracketNode extends DCAstTextNode {
+	
+	enum BracketType {
+		ROUND,
+		CURLY,
+		SQUARE
+	}
+	
+	BracketType type
+	int posClose
+	boolean closed
+	
+	new(DCAstNode parent, BracketType type, DCAstNode contents, int posOpen, int posClose) {
+		super(parent, 2, posOpen, posOpen+1)
+		this.type = type
+		this.posClose = posClose
+		this.closed = posClose>=0
+		
+		if (contents!==null) {
+			contents.parent = this
+		}
+	}
+	
+	new(DCAstNode parent, BracketType type, DCAstNode contents, int posOpen) {
+		this(parent, type, contents, posOpen, -1)
+	}
+	
+	def left() {
+		switch type {
+			case CURLY: "{"
+			case ROUND: "("
+			case SQUARE: "["
+		}
+	}
+	
+	def right() {
+		switch type {
+			case CURLY: "}"
+			case ROUND: ")"
+			case SQUARE: "]"
+		}
+	}
+	
+	override toString() {
+		switch type {
+			case CURLY: "{}"
+			case ROUND: "()"
+			case SQUARE: "[]"
+		}
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstBracketNode " + this.toString)
+	}
+	
+	override def String getText() { toString }
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstFeatureCallNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstFeatureCallNode.xtend
new file mode 100644
index 000000000..4cabcbb30
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstFeatureCallNode.xtend
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+
+class DCAstFeatureCallNode extends DCAstNode {
+	
+	new(DCAstNode parent) {
+		super(parent, 0)
+	}
+	
+	override protected doPrint(String indent) {
+		val extra = if (incomplete) " (incomplete)" else ""
+		println(indent + "DCAstFeatureCallNode" + extra)
+	}
+	
+	def isIncomplete() {
+		!children.empty && children.last instanceof DCAstPeriodNode
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierBracketNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierBracketNode.xtend
new file mode 100644
index 000000000..51c69e5af
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierBracketNode.xtend
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+
+abstract class DCAstIdentifierBracketNode extends DCAstNode {
+	
+	new(DCAstNode parent, DCAstIdentifierNode id, DCAstWhitespaceNode ws, DCAstBracketNode bracket) {
+		super(parent, 0 /* consumed no tokens itself */)
+		
+		id.parent = this
+		
+		if (ws!==null) {
+			ws.parent = this
+		}
+		
+		bracket.parent = this
+	}
+	
+	def DCAstIdentifierNode idNode() {
+		children.head as DCAstIdentifierNode
+	}
+	
+	def String id() {
+		idNode.id
+	}
+	
+	def String ws() {
+		if (children.size==3) {
+			(children.get(1) as DCAstWhitespaceNode).text
+		}
+		else {
+			""
+		}
+	}
+	
+	def DCAstBracketNode bracketNode() {
+		children.last as DCAstBracketNode
+	}
+	
+	def String bracket() {
+		bracketNode.toString
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierNode.xtend
new file mode 100644
index 000000000..b330891b5
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstIdentifierNode.xtend
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCTextToken
+import org.eclipse.xtend.lib.annotations.Accessors
+
+@Accessors
+class DCAstIdentifierNode extends DCAstTextNode {
+	
+	String id
+	DCTextToken token
+	
+	new(DCAstNode parent, String id, DCTextToken token) {
+		super(parent, 1, token.begin, token.begin+token.length)
+		this.id = id
+		this.token = token
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstIdentifierNode '" + id + "'" + linkedObjectText)
+	}
+	
+	override getText() { id }
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstMatchNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstMatchNode.xtend
new file mode 100644
index 000000000..43537a08a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstMatchNode.xtend
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+class DCAstMatchNode extends DCAstNode {
+	
+	new(DCAstNode parent) {
+		super(parent, 0 /* no own tokens */)
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstMatchNode")
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstNode.xtend
new file mode 100644
index 000000000..e27e67ded
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstNode.xtend
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.etrice.dctools.fsm.ast.util.IDCAstNodeVisitor
+
+@Accessors
+abstract class DCAstNode {
+	
+	DCAstNode parent
+	int readTokens
+	List<DCAstNode> children = newArrayList
+	EObject linkedObject
+	Object linkedData
+	
+	new() {
+		this(null, 0)
+	}
+	
+	new(DCAstNode parent, int readTokens) {
+		this.parent = parent
+		this.readTokens = readTokens
+		if (parent!==null) {
+			parent.children.add(this)
+		}
+	}
+	
+	def DCAstNode c(int i) {
+		children.get(i)
+	}
+	
+	def void setParent(DCAstNode parent) {
+		if (this.parent!==null) {
+			this.parent.children.remove(this)
+		}
+		this.parent = parent
+		if (parent!==null) {
+			this.parent.children.add(this)
+		}
+	}
+	
+	def int totallyReadTokens() {
+		var sum = readTokens
+		for (child : children) {
+			sum += child.totallyReadTokens
+		}
+		return sum
+	}
+	
+	def void print() {
+		printRecursive("")
+	}
+	
+	def void visit(IDCAstNodeVisitor visitor) {
+		val descend = visitor.visitBegin(this)
+		
+		if (descend) {
+			for (child : children) {
+				child.visit(visitor)
+			}
+		}
+		
+		visitor.visitEnd(this)
+	}
+	
+	protected def void printRecursive(String indent) {
+		doPrint(indent)
+		for (child : children) {
+			child.printRecursive(indent + "  ")
+		}
+	}
+	
+	protected def String getLinkedObjectText() {
+		if (linkedObject!==null) {
+			return " --> " + linkedObject.eClass.name
+		}
+		else {
+			""
+		}
+	}
+	
+	protected abstract def void doPrint(String indent)
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOperationCallNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOperationCallNode.xtend
new file mode 100644
index 000000000..e6fc4fac4
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOperationCallNode.xtend
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierBracketNode
+
+class DCAstOperationCallNode extends DCAstIdentifierBracketNode {
+	
+	new(DCAstNode parent, DCAstIdentifierNode id, DCAstWhitespaceNode ws, DCAstBracketNode bracket) {
+		super(parent, id, ws, bracket)
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstOperationCallNode '" + id + ws + bracket + "'" + linkedObjectText)
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOtherNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOtherNode.xtend
new file mode 100644
index 000000000..ee93222d4
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstOtherNode.xtend
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCTextToken
+import org.eclipse.xtend.lib.annotations.Accessors
+
+@Accessors
+class DCAstOtherNode extends DCAstTextNode {
+	
+	String text
+	DCTextToken token
+	
+	new(DCAstNode parent, String text, DCTextToken token) {
+		super(parent, 1, token.begin, token.begin+token.length)
+		this.text = text
+		this.token = token
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstOtherNode '" + text + "' " + token.token.kind)
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstPeriodNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstPeriodNode.xtend
new file mode 100644
index 000000000..a29d353f8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstPeriodNode.xtend
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.internal.DCSpecialCharRule
+
+class DCAstPeriodNode extends DCAstTextNode {
+	
+	new(DCAstNode parent, int pos) {
+		super(parent, 1, pos, pos+1)
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstPeriodNode")
+	}
+	
+	override String getText() { String.valueOf(DCSpecialCharRule.PERIOD) }
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstTextNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstTextNode.xtend
new file mode 100644
index 000000000..c008b3599
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstTextNode.xtend
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.xtend.lib.annotations.Accessors
+
+@Accessors
+abstract class DCAstTextNode extends DCAstNode {
+	
+	int begin
+	int end
+	
+	new(DCAstNode parent, int readTokens, int begin, int end) {
+		super(parent, readTokens)
+		this.begin = begin
+		this.end = end
+	}
+	
+	abstract def String getText()
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstWhitespaceNode.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstWhitespaceNode.xtend
new file mode 100644
index 000000000..1ff691fac
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/nodes/DCAstWhitespaceNode.xtend
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.nodes
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.xtend.lib.annotations.Accessors
+
+@Accessors
+class DCAstWhitespaceNode extends DCAstTextNode {
+	
+	String text
+	
+	new(DCAstNode parent, int readTokens, int pos, String text) {
+		super(parent, readTokens, pos, pos+text.length)
+		this.text = text
+	}
+	
+	override protected doPrint(String indent) {
+		println(indent + "DCAstWhitespaceNode '" + text + "'")
+	}
+	
+	override getText() { text }
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCBracketToken.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCBracketToken.xtend
new file mode 100644
index 000000000..073388b5f
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCBracketToken.xtend
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.tokens
+
+import org.eclipse.etrice.dctools.fsm.ast.tokens.DCBracketToken.BracketKind
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class DCBracketToken extends DCToken {
+
+	enum BracketKind {
+		LEFT_ROUND, RIGHT_ROUND,
+		LEFT_CURLY, RIGHT_CURLY,
+		LEFT_SQUARE, RIGHT_SQUARE
+	}
+	
+	static val leftRoundBracket = new DCBracketToken(BracketKind.LEFT_ROUND)
+	static val rightRoundBracket = new DCBracketToken(BracketKind.RIGHT_ROUND)
+	static val leftCurlyBracket = new DCBracketToken(BracketKind.LEFT_CURLY)
+	static val rightCurlyBracket = new DCBracketToken(BracketKind.RIGHT_CURLY)
+	static val leftSquareBracket = new DCBracketToken(BracketKind.LEFT_SQUARE)
+	static val rightSquareBracket = new DCBracketToken(BracketKind.RIGHT_SQUARE)
+	
+	static val char2token = #{
+		Character.valueOf('(') -> leftRoundBracket,
+		Character.valueOf(')') -> rightRoundBracket,
+		Character.valueOf('{') -> leftCurlyBracket,
+		Character.valueOf('}') -> rightCurlyBracket,
+		Character.valueOf('[') -> leftSquareBracket,
+		Character.valueOf(']') -> rightSquareBracket
+	}
+	
+	BracketKind bracketKind
+	
+	private new(BracketKind bk) {
+		super(Kind.BRACKET)
+		this.bracketKind = bk
+	}
+	
+	static def getToken(char c) {
+		char2token.get(c)
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCTextToken.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCTextToken.xtend
new file mode 100644
index 000000000..0a119c6ca
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCTextToken.xtend
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.tokens
+
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class DCTextToken {
+	int begin
+	int length
+	DCToken token
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCToken.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCToken.xtend
new file mode 100644
index 000000000..c6dc4ec80
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/tokens/DCToken.xtend
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.tokens
+
+import org.eclipse.jface.text.rules.IToken
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class DCToken implements IToken {
+	
+	enum Kind {
+		COMMENT,
+		STRING,
+		WHITESPACE,
+		PERIOD,
+		STATEMENT_SEP,
+		BRACKET,
+		NUMBER,
+		KEYWORD,
+		IDENTIFIER,
+		OTHER,
+		EOF
+	}
+	
+	Kind kind
+	
+	override getData() {
+		null
+	}
+	
+	override isEOF() {
+		kind===Kind.EOF
+	}
+	
+	override isOther() {
+		kind===Kind.OTHER
+	}
+	
+	override isUndefined() {
+		false
+	}
+	
+	override isWhitespace() {
+		kind===Kind.WHITESPACE
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/DCAstPrinter.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/DCAstPrinter.xtend
new file mode 100644
index 000000000..7811910eb
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/DCAstPrinter.xtend
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.util
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstPeriodNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstWhitespaceNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOtherNode
+
+class DCAstPrinter implements IDCAstNodeVisitor {
+	
+	val sb = new StringBuilder
+	
+	def getText() {
+		sb.toString
+	}
+	
+	override visitBegin(DCAstNode node) {
+		
+		switch node {
+			DCAstBracketNode: sb.append(node.left)
+			DCAstIdentifierNode: sb.append(node.id)
+			DCAstPeriodNode: sb.append(".")
+			DCAstWhitespaceNode: sb.append(node.text)
+			DCAstOtherNode: sb.append(node.text)
+		}
+		
+		return true
+	}
+	
+	override visitEnd(DCAstNode node) {
+		switch node {
+			DCAstBracketNode: if (node.closed) sb.append(node.right)
+		}
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/IDCAstNodeVisitor.xtend b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/IDCAstNodeVisitor.xtend
new file mode 100644
index 000000000..d430bf589
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools.fsm/src/org/eclipse/etrice/dctools/fsm/ast/util/IDCAstNodeVisitor.xtend
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.fsm.ast.util
+
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+
+interface IDCAstNodeVisitor {
+	
+	def boolean visitBegin(DCAstNode node)
+	def void visitEnd(DCAstNode node)
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/.classpath b/plugins/org.eclipse.etrice.dctools/.classpath
new file mode 100644
index 000000000..428337e56
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="xtend-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.etrice.dctools/.gitignore b/plugins/org.eclipse.etrice.dctools/.gitignore
new file mode 100644
index 000000000..1a7726dc2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/.gitignore
@@ -0,0 +1,4 @@
+bin
+*._trace
+*.smap
+*.xtendbin
diff --git a/plugins/org.eclipse.etrice.dctools/.project b/plugins/org.eclipse.etrice.dctools/.project
new file mode 100644
index 000000000..af0ef944b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.etrice.dctools</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/org.eclipse.etrice.dctools/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.dctools/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.dctools/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.dctools/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..9a9f24843
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/META-INF/MANIFEST.MF
@@ -0,0 +1,23 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Detail Code Tools
+Bundle-SymbolicName: org.eclipse.etrice.dctools
+Bundle-Version: 1.1.3.qualifier
+Bundle-Vendor: Eclipse eTrice
+Automatic-Module-Name: org.eclipse.etrice.dctools
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: com.google.guava,
+ org.eclipse.emf.ecore,
+ org.eclipse.jface.text,
+ org.eclipse.xtext.xbase.lib,
+ org.eclipse.xtend.lib,
+ org.eclipse.xtend.lib.macro,
+ org.eclipse.xtext.ui,
+ org.eclipse.etrice.core.fsm,
+ org.eclipse.etrice.core.room,
+ org.eclipse.etrice.dctools.fsm;visibility:=reexport,
+ org.eclipse.etrice.generator.fsm,
+ org.eclipse.etrice.core.genmodel.fsm
+Export-Package: org.eclipse.etrice.dctools,
+ org.eclipse.etrice.dctools.ast
+
diff --git a/plugins/org.eclipse.etrice.dctools/build.properties b/plugins/org.eclipse.etrice.dctools/build.properties
new file mode 100644
index 000000000..d8e2f0e92
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\
+           xtend-gen/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/GenModelAccess.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/GenModelAccess.xtend
new file mode 100644
index 000000000..340b069b8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/GenModelAccess.xtend
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools
+
+import java.util.Map
+import org.eclipse.etrice.core.RoomStandaloneSetup
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+
+class GenModelAccess {
+	
+		Map<ModelComponent, GraphContainer> cache = newHashMap
+		
+		def public GraphContainer get(ModelComponent mc) {
+			if(!cache.containsKey(mc)) {
+				val injector = new RoomStandaloneSetup().createInjector
+				val builder = new ExtendedFsmGenBuilder(injector);
+				val gc = builder.createTransformedModel(mc)
+				builder.withCommonData(gc)
+				cache.put(mc, gc)
+			}
+			
+			return cache.get(mc)
+		}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCLinker.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCLinker.xtend
new file mode 100644
index 000000000..d703ea1ff
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCLinker.xtend
@@ -0,0 +1,278 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast
+
+import java.util.Deque
+import java.util.LinkedList
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.etrice.core.fsm.fSM.StateGraphItem
+import org.eclipse.etrice.core.room.ActorClass
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.EnumerationType
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.MessageData
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.Port
+import org.eclipse.etrice.core.room.PortClass
+import org.eclipse.etrice.core.room.RoomClass
+import org.eclipse.etrice.core.room.SAP
+import org.eclipse.etrice.core.room.VarDecl
+import org.eclipse.etrice.core.room.util.RoomHelpers
+import org.eclipse.etrice.dctools.fsm.ast.CandidateMap
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstArrayAccessNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstFeatureCallNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOperationCallNode
+import org.eclipse.etrice.dctools.fsm.ast.util.IDCAstNodeVisitor
+
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.*
+
+import static extension org.eclipse.xtext.EcoreUtil2.*
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+
+class DCLinker implements IDCAstNodeVisitor {
+	
+	enum FeatureType {
+		SCALAR,
+		ARRAY,
+		OPERATION
+	}
+	
+	EObject owner
+	EReference reference
+	MessageData transitionData
+	
+	protected val extension RoomHelpers roomHelpers = new RoomHelpers
+	
+	val Deque<EObject> contexts = new LinkedList
+	
+	new(DetailCode dc) {
+		this(dc.eContainer, dc.eContainingFeature as EReference)
+	}
+	
+	new(EObject owner, EReference reference) {
+		this(owner, reference, null)
+	}
+	
+	new(DetailCode dc, MessageData transitionData) {
+		this(dc.eContainer, dc.eContainingFeature as EReference, transitionData)
+	}
+	
+	new(EObject owner, EReference reference, MessageData transitionData) {
+		this.owner = owner
+		this.reference = reference
+		this.transitionData = transitionData
+	}
+	
+	override visitBegin(DCAstNode node) {
+		switch node {
+			DCAstFeatureCallNode: {
+				// a feature call always starts in the global context
+				contexts.push(owner)
+			}
+			DCAstIdentifierNode case node.parent instanceof DCAstFeatureCallNode: link(node)
+			DCAstArrayAccessNode: link(node)
+			DCAstOperationCallNode: link(node)
+		}
+		
+		return true
+	}
+	
+	override visitEnd(DCAstNode node) {
+		switch node {
+			DCAstFeatureCallNode: contexts.pop
+		}
+	}
+	
+	protected def dispatch void link(DCAstIdentifierNode node) {
+		node.doLink(FeatureType.SCALAR, node.id)
+	}
+	
+	protected def dispatch void link(DCAstArrayAccessNode node) {
+		node.doLink(FeatureType.ARRAY, node.id)
+	}
+	
+	protected def dispatch void link(DCAstOperationCallNode node) {
+		node.doLink(FeatureType.OPERATION, node.id)
+	}
+	
+	protected def void doLink(DCAstNode node, FeatureType ft, String name) {
+		val candidates = getCandidates(ft)
+		node.linkedObject = candidates.get(name)
+		node.linkedData = candidates
+		replaceContext(node.linkedObject)
+	}
+	
+	protected def replaceContext(EObject obj) {
+		contexts.pop
+		contexts.push(obj?.contextOf)
+	}
+	
+	protected def dispatch getContextOf(EObject obj) {
+		null
+	}
+	
+	protected def dispatch getContextOf(Port port) {
+		port
+	}
+	
+	protected def dispatch getContextOf(Attribute att) {
+		att.type.type
+	}
+	
+	protected def dispatch getContextOf(VarDecl vd) {
+		vd.refType.type
+	}
+	
+	protected def dispatch getContextOf(MessageData md) {
+		md?.refType?.type
+	}
+	
+	protected def dispatch getContextOf(Operation op) {
+		op?.returnType?.type
+	}
+	
+	//http://git.eclipse.org/c/etrice/org.eclipse.etrice.git/tree/tests/org.eclipse.etrice.generator.common.tests/models/EnumTest.room?h=newfsmgen_finalize&id=79aa00b074c61bde5173d4859ce2b52e50b52dec#n117
+	
+	protected def getCandidates(FeatureType type) {
+		val candidates = new CandidateMap
+		
+		if (contexts.peek===owner) {
+			// this is the top level
+			topLevelCandidates(candidates, type)
+		}
+		else {
+			val current = contexts.peek
+			switch current {
+				DataClass: {
+					current.getCandidates(type, candidates)
+				}
+				
+				InterfaceItem: {
+					current.getCandidates(candidates)
+				}
+				
+				Attribute case current.type?.type instanceof DataClass: {
+					val dc = current.type.type as DataClass
+					dc.getCandidates(type, candidates)
+				}
+				MessageData case current.refType?.type instanceof DataClass: {
+					val dc = current.refType.type as DataClass
+					dc.getCandidates(type, candidates)
+				}
+				EnumerationType: {
+					// from descriptions, have to be resolved
+					var enumType = current
+					if (current.eIsProxy) {
+						val resolved = EcoreUtil.resolve(current, owner)
+						if (resolved instanceof EnumerationType)
+							enumType = resolved
+					}
+					enumType.literals.forEach[candidates.put(it.name, it)]	
+				}
+			}
+		}
+		
+		return candidates
+	}
+	
+	protected def void topLevelCandidates(CandidateMap candidates, FeatureType type) {
+		// operation arguments
+		owner.getContainerOfType(Operation)?.arguments?.forEach[candidates.put(it.name, it)]
+		
+		// TODO: compare with org.eclipse.etrice.expressions.detailcode.DetailExpressionProvider.initialFsmExpression(EObject, ActorClass, List<ExpressionFeature>)
+		if (!reference.name.contains('userCode')) {
+			val roomClass = owner.getContainerOfType(RoomClass)
+			switch roomClass {
+				ActorClass: {
+					if (transitionData!==null) {
+						candidates.put("transitionData", transitionData)
+					}
+					if (type==FeatureType.SCALAR) {
+						roomClass.allAttributes.forEach[candidates.put(it.name, it)]
+					}
+					if (type==FeatureType.ARRAY) {
+						roomClass.allAttributes.filter[size>1].forEach[candidates.put(it.name, it)]
+					}
+					if (type==FeatureType.OPERATION) {
+						roomClass.latestOperations.forEach[candidates.put(it.name, it)]
+					}
+					roomClass.allInterfaceItems.forEach[
+						switch it {
+							Port case type==FeatureType.SCALAR: candidates.put(it.name, it)
+							Port case type==FeatureType.ARRAY && it.replicated: candidates.put(it.name, it)
+							SAP case type==FeatureType.SCALAR: candidates.put(it.name, it)
+						}
+					]
+				}
+				
+				DataClass: {
+					roomClass.getCandidates(type, candidates)
+				}
+				
+				case owner.getContainerOfType(PortClass)!==null: {
+					val portClass = owner.getContainerOfType(PortClass)
+					// TODO inheritance
+					portClass.operations.forEach[candidates.put(it.name, it)]
+					portClass.attributes.forEach[candidates.put(it.name, it)]
+				}
+			}
+		}
+	}
+	
+	protected def void getCandidates(DataClass dataClass, FeatureType type, CandidateMap candidates) {
+		if (type==FeatureType.SCALAR) {
+			dataClass.allAttributes.forEach[candidates.put(it.name, it)]
+		}
+		if (type==FeatureType.ARRAY) {
+			dataClass.allAttributes.filter[size>1].forEach[candidates.put(it.name, it)]
+		}
+		if (type==FeatureType.OPERATION) {
+			dataClass.latestOperations.forEach[candidates.put(it.name, it)]
+		}
+	}
+	
+	protected def void getCandidates(InterfaceItem ifItem, CandidateMap candidates) {
+		// operations
+		ifItem.protocol.getAllOperations(!ifItem.conjugated).forEach[candidates.put(it.name, it)]
+		
+		// messages
+		switch reference {
+			case CP_BRANCH_TRANSITION__CONDITION,
+			case GUARDED_TRANSITION__GUARD,
+			case GUARD__GUARD: {
+				val pc = ifItem.protocol
+				switch pc?.commType {
+					case DATA_DRIVEN:
+						if (!ifItem.conjugated) pc.allIncomingMessages.forEach[candidates.put(it.name, it)]
+					case EVENT_DRIVEN: { /* no async message calls */}
+					case SYNCHRONOUS: {}
+				}
+			}
+			case owner.getContainerOfType(StateGraphItem)!==null: {
+				val pc = ifItem.protocol
+				switch pc?.commType {
+					case EVENT_DRIVEN:
+						pc.getAllMessages(ifItem.conjugated).forEach[candidates.put(it.name, it)]
+					case DATA_DRIVEN:
+						pc.allIncomingMessages.forEach[candidates.put(it.name, it)]
+					case SYNCHRONOUS: {}
+				}				
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCTranslator.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCTranslator.xtend
new file mode 100644
index 000000000..7c72cd54b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCTranslator.xtend
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2018 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast
+
+import org.eclipse.etrice.generator.fsm.generic.IDetailCodeTranslator
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.dctools.ast.internal.DCTranslatorVisitor
+import org.eclipse.etrice.core.room.util.RoomHelpers
+import org.eclipse.etrice.generator.fsm.base.IFSMTranslationProvider
+import org.eclipse.etrice.dctools.fsm.ast.DCLanguage
+import org.eclipse.etrice.dctools.fsm.ast.DCParser
+import org.eclipse.etrice.core.room.MessageData
+
+class DCTranslator implements IDetailCodeTranslator {
+	
+	DCLanguage language
+	ITranslationProvider translationProvider
+	
+	val extension RoomHelpers roomHelpers = new RoomHelpers
+	
+	new(DCLanguage language, ITranslationProvider translationProvider) {
+		this.language = language
+		this.translationProvider = translationProvider
+	}
+	
+	override getTranslatedCode(DetailCode dc) {
+		return getTranslatedCode(dc, null)
+	}
+	
+	def getTranslatedCode(DetailCode dc, MessageData transitionData) {
+		var code = dc.detailCode
+
+		// before the actual parsing is done we translate tags
+		if (translationProvider.translateTags) {
+			code = translateTags(code, dc)
+		}
+		
+		// parse
+		val parser = new DCParser(language)
+		val ast = parser.parse(code)
+		
+		// link
+		val linker = new DCLinker(dc, transitionData)
+		ast.visit(linker)
+		
+		// translate
+		val visitor = new DCTranslatorVisitor(translationProvider)
+		ast.visit(visitor)
+		
+		return visitor.translatedCode
+	}
+	
+	def translateTags(String text, DetailCode dc) {
+		val result = new StringBuilder
+		
+		var int last = 0
+		var int next = text.indexOf(IFSMTranslationProvider.TAG_START, last)
+		while (next >= 0) {
+			result.append(text.substring(last, next))
+			last = next + IFSMTranslationProvider.TAG_START.length()
+			next = text.indexOf(IFSMTranslationProvider.TAG_END, last)
+			if (next >= 0) {
+				val String tag = text.substring(last, next)
+				result.append(translationProvider.translateTag(tag, dc))
+				last = next + IFSMTranslationProvider.TAG_END.length()
+				next = text.indexOf(IFSMTranslationProvider.TAG_START, last)
+			}
+		}
+		result.append(text.substring(last))
+
+		return result.toString
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCUtil.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCUtil.xtend
new file mode 100644
index 000000000..e2f580939
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/DCUtil.xtend
@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast
+
+import com.google.inject.Inject
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.converter.RoomValueConverterService
+import org.eclipse.etrice.core.fsm.fSM.DetailCode
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions
+import org.eclipse.etrice.core.room.ActorClass
+import org.eclipse.etrice.core.room.MessageData
+import org.eclipse.etrice.core.room.RoomClass
+import org.eclipse.etrice.dctools.GenModelAccess
+import org.eclipse.etrice.dctools.ast.internal.DCProposalConfig
+import org.eclipse.etrice.dctools.fsm.ast.CandidateMap
+import org.eclipse.etrice.dctools.fsm.ast.DCLanguage
+import org.eclipse.etrice.dctools.fsm.ast.DCNodeAtOffset
+import org.eclipse.etrice.dctools.fsm.ast.DCParser
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.jface.text.contentassist.ICompletionProposal
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtext.EcoreUtil2
+import org.eclipse.xtext.nodemodel.ILeafNode
+import org.eclipse.xtext.nodemodel.INode
+
+class DCUtil {
+	
+	@Accessors
+	static class FindResult {
+		val EObject object
+		val int begin
+		val int length
+	}
+	
+	@Inject RoomValueConverterService converterService
+	@Inject DCProposalConfig proposalConfig
+	
+	val genModelAccess = new GenModelAccess
+	DCLanguage language = DCLanguage.C_LANGUAGE
+	
+	new() {
+	}
+	
+	def setLanguage(DCLanguage language) {
+		this.language = language
+	}
+	
+	def FindResult findAtOffset(ILeafNode textNode, int offset) {
+		val ast = textNode.parseAndLink
+		val astNode = DCNodeAtOffset.find(ast, offset - textNode.delimiterAdjustedOffset)
+		if (astNode instanceof DCAstIdentifierNode) {
+			val object = getLinkedObject(astNode)
+			if (object !==null) {
+				return new FindResult(object, astNode.begin + converterService.CC_StringConverter.delim.length, astNode.end-astNode.begin)
+			}
+		}
+		return null
+	}
+	
+	def getDelimiterAdjustedOffset(INode astNode) {
+		astNode.offset + converterService.CC_StringConverter.delim.length
+	}
+	
+	def parseAndLink(INode astNode) {
+		val text = converterService.CC_StringConverter.stripDelim(astNode.getText());
+		val parser = new DCParser(language)
+		val ast = parser.parse(text)
+		
+		if (astNode.parent.semanticElement instanceof DetailCode) {
+			val dc = astNode.parent.semanticElement as DetailCode
+			
+			var DCLinker linker = null;
+			
+			// lets check whether we have a transition and determine common data
+			val transition = EcoreUtil2.getContainerOfType(dc, TransitionBase)
+			if (transition!==null) {
+				val roomClass = EcoreUtil2.getContainerOfType(dc, RoomClass)
+				if (roomClass instanceof ActorClass) {
+					val gc = genModelAccess.get(roomClass)
+					val link = FsmGenExtensions.getLinkFor(gc, transition)
+					if (link!==null) {
+						linker = new DCLinker(dc, link.commonData as MessageData)
+					}
+				}
+			}
+			
+			// if we have no common data we use a plain linker
+			if (linker===null) {
+				linker = new DCLinker(dc)
+			}
+			
+			ast.visit(linker)
+			
+			return ast
+		}
+		else {
+			return null
+		}
+	}
+	
+	def List<ICompletionProposal> getProposals(INode textNode, int offset) {
+		val ast = textNode.parseAndLink
+		// note: we subtract 1 to get the token to the left of the caret
+		val astNode = DCNodeAtOffset.find(ast, offset - textNode.delimiterAdjustedOffset - 1)
+		if (astNode instanceof DCAstIdentifierNode) {
+			val candidates = astNode.candidates
+			if (candidates!==null) {
+				val begin = astNode.begin + converterService.CC_StringConverter.delim.length
+				val end = offset - textNode.offset
+				val prefix = textNode.text.substring(begin, end)
+				val matches = candidates.getMatches(prefix)
+				return matches.entrySet.map[match | proposalConfig.doCreateProposal(prefix, match.key, match.value, offset)].toList
+			}
+		}
+		
+		newArrayList
+	}
+	
+	static def EObject getLinkedObject(DCAstIdentifierNode astNode) {
+		if (astNode.linkedObject!==null) {
+			astNode.linkedObject
+		}
+		else if (astNode.parent!==null) {
+			astNode.parent.linkedObject
+		}
+	}
+	
+	static def CandidateMap getCandidates(DCAstIdentifierNode astNode) {
+		if (astNode.linkedData instanceof CandidateMap) {
+			astNode.linkedData as CandidateMap
+		}
+		else if (astNode.parent!==null && astNode.parent.linkedData instanceof CandidateMap) {
+			astNode.parent.linkedData as CandidateMap
+		}
+	}
+}
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/ITranslationProvider.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/ITranslationProvider.xtend
new file mode 100644
index 000000000..2bb57091d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/ITranslationProvider.xtend
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast
+
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.PortOperation
+import org.eclipse.etrice.core.room.EnumLiteral
+import org.eclipse.etrice.dctools.fsm.ast.IFSMTranslationProvider
+
+/** 
+ * This interface is used by the detail code translator to replace
+ * common constructs in detail level code with a target language specific
+ * piece of code.
+ * <p>
+ * The constructs that are replaced are
+ * <ul>
+ * <li>attributes</li>
+ * <li>operations</li>
+ * <li>port.message</li>
+ * <li>tags of the form <code><|tag|></code></li>
+ * </ul>
+ * </p>
+ * @see DCTranslator
+ * @author Henrik Rentz-Reichert
+ */
+interface ITranslationProvider extends IFSMTranslationProvider{
+	
+	/** 
+	 * yield text to read an attribute (array index may be null). Is called whenever <i>attribute</i> 
+	 * or <i>attribute</i>[<i>index</i>] or is
+	 * found in the detail code
+	 * @param att the actor class attribute
+	 * @param instance a pointer to the instance object
+	 * @param index the index (should be null for scalars, !=null for arrays)
+	 * @param orig the original text
+	 * @return the translation
+	 */
+	def String getAttributeGetter(Attribute att, String instance, String index, String orig) 
+	
+	/** 
+	 * yield text to write an attribute (array index may be null). Is called whenever <i>attribute</i>.set(<i>value</i>)
+	 * or <i>attribute</i>[<i>index</i>].set(<i>value</i>) is
+	 * found in the detail code
+	 * @param att the actor class attribute
+	 * @param instance a pointer to the instance object
+	 * @param index the index (should be null for scalars, !=null for arrays)
+	 * @param value to assign to the attribute
+	 * @param orig the original text
+	 * @return the translation
+	 */
+	def String getAttributeSetter(Attribute att, String instance, String index, String value, String orig) 
+	
+	/** 
+	 * yield text for operation call. Is called whenever <i>operation</i>(<i>args</i>)
+	 * is found in the detail code
+	 * @param op operation to call
+	 * @param instance a pointer to the defining class instance
+	 * @param args the arguments to pass
+	 * @param orig the original text
+	 * @return the translation
+	 */
+	def String getOperationText(Operation op, String instance, String args, String orig) 
+	
+	/** 
+	 * yields a sequence that reads data from a <b>data driven</b> port.
+	 * Is called whenever <i>port</i>.<i>msg</i> or <i>port</i>[<i>index</i>].<i>msg</i>
+	 * is found in the detail code
+	 * @param item the interface item
+	 * @param msg the message to read
+	 * @param orig the original text
+	 * @return the translation
+	 */
+	def String getInterfaceItemMessageValue(InterfaceItem item, Message msg, String orig) 
+	
+	/** 
+	 * @return true if translations are provided for enumerations
+	 */
+	def boolean translateEnums() 
+	
+	/** 
+	 * yields a replacement for &lt;enumtype>.&lt;literal>
+	 * @param literal the enumeration literal to be translated
+	 * @return the translated enumeration literal
+	 */
+	def String getEnumText(EnumLiteral literal) 
+	
+	/** 
+	 * yields a call to an operation of an interface item
+	 * @param item the interface item
+	 * @param op the port class operation
+	 * @param instance a pointer to the defining class instance
+	 * @param args the argument list
+	 * @param orig the original test
+	 * @return the translation
+	 */
+	def String getInterfaceItemOperationText(AbstractInterfaceItem item, PortOperation op, String instance, String args, String orig) 
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCProposalConfig.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCProposalConfig.xtend
new file mode 100644
index 000000000..8f28887cd
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCProposalConfig.xtend
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast.internal
+
+import com.google.inject.Singleton
+import com.google.inject.Inject
+import org.eclipse.jface.viewers.ILabelProvider
+import org.eclipse.etrice.core.room.util.RoomHelpers
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.jface.viewers.StyledString
+import org.eclipse.swt.graphics.Image
+import org.eclipse.xtext.ui.editor.contentassist.ConfigurableCompletionProposal
+import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher
+import org.eclipse.jface.text.contentassist.ICompletionProposal
+import org.eclipse.swt.graphics.Point
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.Port
+
+@Singleton
+class DCProposalConfig {
+
+	@Inject
+	protected ILabelProvider labelProvider
+
+	@Inject
+	protected RoomHelpers roomHelpers
+	
+	@Inject
+	protected PrefixMatcher prefixMatcher
+	
+	def ICompletionProposal doCreateProposal(String prefix, String proposal, EObject object, int globalOffset) {
+		new ConfigurableCompletionProposal(proposal, globalOffset - prefix.length, prefix.length, proposal.length, object.image, object.displayString, null, null) => [
+			matcher = prefixMatcher
+			autoInsertable = false
+			// TODO adjust length to existing text
+			replaceContextLength = proposal.length
+		]
+	}
+
+	def Pair<String, Point> getPostfixReplacement(EObject object) {
+		val brackets = switch object {
+			Operation,
+			Message:
+				#['(', ')']
+			
+			Attribute case object.size>0,
+			Port case object.multiplicity>0:
+				#['[', ']']
+		}
+		
+		if (brackets===null) {
+			return "" -> null
+		}
+		
+		val replacement = switch object {
+			Operation:
+				object.arguments.map[name].join(', ')
+			
+			Message case object.data !== null:
+				object.data.refType.type.name
+			
+			Attribute, // fall through
+			InterfaceItem:
+				'0'
+			
+			default:
+				''
+		}
+
+		replacement.wrap(brackets.head, brackets.last)
+	}
+	
+	private def Pair<String, Point> wrap(String text, String left, String right) {
+		val selection = if (!text.empty) new Point(1, text.length)
+		left + text + right -> selection
+	}
+	
+	private def StyledString getDisplayString(EObject object) {
+		
+	}	
+
+	private def Image getImage(EObject object) {
+		
+	}	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCTranslatorVisitor.xtend b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCTranslatorVisitor.xtend
new file mode 100644
index 000000000..c307273d1
--- /dev/null
+++ b/plugins/org.eclipse.etrice.dctools/src/org/eclipse/etrice/dctools/ast/internal/DCTranslatorVisitor.xtend
@@ -0,0 +1,246 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.dctools.ast.internal
+
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.dctools.ast.ITranslationProvider
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstArrayAccessNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstBracketNode.BracketType
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstIdentifierNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOperationCallNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstOtherNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstPeriodNode
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstWhitespaceNode
+import org.eclipse.etrice.dctools.fsm.ast.util.DCAstPrinter
+import org.eclipse.etrice.dctools.fsm.ast.util.IDCAstNodeVisitor
+import org.eclipse.etrice.dctools.fsm.ast.nodes.DCAstFeatureCallNode
+import org.eclipse.etrice.core.room.Port
+import org.eclipse.etrice.core.room.VarDecl
+
+class DCTranslatorVisitor implements IDCAstNodeVisitor {
+
+	ITranslationProvider translationProvider
+	
+	val sb = new StringBuilder
+	var currentSB = sb
+	
+	new(ITranslationProvider translationProvider) {
+		this.translationProvider = translationProvider
+	}
+	
+	def String getTranslatedCode() {
+		sb.toString
+	}
+	
+	
+	override visitBegin(DCAstNode node) {
+		
+		if (node instanceof DCAstBracketNode) {
+			if (node.shouldCollectArguments) {
+				currentSB = new StringBuilder
+				node.linkedData = currentSB
+			}
+			else {
+				currentSB.append(node.left)
+			}
+		}
+		else {
+			if (!node.skipOutput) {
+				switch node {
+					DCAstIdentifierNode: currentSB.append(node.id)
+					DCAstPeriodNode: currentSB.append(".")
+					DCAstWhitespaceNode: currentSB.append(node.text)
+					DCAstOtherNode: currentSB.append(node.text)
+				}
+			}
+		}
+		
+		return true
+	}
+	
+	override visitEnd(DCAstNode node) {
+		switch node {
+			DCAstBracketNode: {
+				if (node.linkedData!==null) {
+					// leave the nested StringBuilder and switch to the enclosing (or top) one
+					currentSB = node.enclosingSB
+				}
+				else if (node.closed) {
+					currentSB.append(node.right)
+				}
+			}
+			
+			DCAstFeatureCallNode case node.canTranslate: node.translate
+		}
+	}
+	
+	private def canTranslate(DCAstFeatureCallNode node) {
+		// if all even children are linked then we can translate the whole
+		for (var i=0; i<node.children.size; i=i+2) {
+			if (node.c(i).linkedObject===null) {
+				return false
+			}
+		}
+		
+		// make sure the last child is not a period
+		val lastNode = node.children.last
+		if (lastNode instanceof DCAstPeriodNode) {
+			return false
+		}
+		
+		return true
+	}
+	
+	private def translate(DCAstFeatureCallNode node) {
+		val lastNode = node.children.last
+		var linkedObject = lastNode.linkedObject
+		
+		// TODO: handle getter for data driven ports: port.message - i.e. no () after message
+		
+		if (lastNode instanceof DCAstOperationCallNode) {
+			if (linkedObject instanceof Message) {
+				handleSendMessage(lastNode, linkedObject)
+				return
+			}
+		}
+		
+		node.handleCallChain
+	}
+	
+	def handleCallChain(DCAstFeatureCallNode node) {
+		var String instance = null
+		for (var i=0; i<node.children.size; i=i+2) {
+			val childNode = node.c(i)
+			val linkedObject = childNode.linkedObject
+			switch linkedObject {
+				Attribute: {
+					val index = if (childNode instanceof DCAstArrayAccessNode) {
+						(childNode.bracketNode.linkedData as StringBuilder).toString
+					}
+					instance = translationProvider.getAttributeGetter(linkedObject, instance, index, childNode.originalText)
+				}
+				
+				VarDecl: {
+					instance = linkedObject.name
+				}
+				
+				Operation: {
+					val args = if (childNode instanceof DCAstOperationCallNode) {
+						(childNode.bracketNode.linkedData as StringBuilder).toString
+					}
+					instance = translationProvider.getOperationText(linkedObject, instance, args, childNode.originalText)
+				}
+			}
+		}
+		currentSB.append(instance)
+	}
+	
+	private def handleSendMessage(DCAstOperationCallNode msgNode, Message msg) {
+		val args = (msgNode.bracketNode.linkedData as StringBuilder).toString
+		// look back to interface item
+		val ifItemNode = msgNode.parent.c(0)
+		val ifItem = ifItemNode.linkedObject as InterfaceItem
+		
+		val translated =
+			if (ifItemNode instanceof DCAstIdentifierNode) {
+				// accessed as scalar (means broadcast for replicated port)
+				val inst = ifItemNode.id
+				translationProvider.getInterfaceItemMessageText(ifItem, msg, inst, args, null, msgNode.originalText)
+			}
+			else if (ifItemNode instanceof DCAstArrayAccessNode) {
+				// accessed as array
+				val inst = ifItemNode.id
+				val index = (ifItemNode.bracketNode.linkedData as StringBuilder).toString
+				translationProvider.getInterfaceItemMessageText(ifItem, msg, inst, args, index, msgNode.originalText)
+			}
+			else {
+				// TODO: assert(false)
+				"internal translator error"
+			}
+		currentSB.append(translated)
+	}
+	
+	private def skipOutput(DCAstNode node) {
+		val surroundingContext = node.getEnclosingBracketOrFeatureCall
+		
+		// check whether we are inside a bracket without a feature call
+		if (surroundingContext instanceof DCAstBracketNode) {
+			return false
+		}
+		
+		if (surroundingContext instanceof DCAstFeatureCallNode) {
+			return surroundingContext.canTranslate
+		}
+		
+		return false
+	}
+	
+	private def getEnclosingBracketOrFeatureCall(DCAstNode node) {
+		var parent = node.parent
+		while (parent!==null) {
+			if (parent instanceof DCAstFeatureCallNode || parent instanceof DCAstBracketNode) {
+				return parent
+			}
+			parent = parent.parent
+		}
+		
+		return null
+	}
+	
+	private def getOriginalText(DCAstNode node) {
+		val printer = new DCAstPrinter
+		node.visit(printer)
+		return printer.text
+	}
+	
+	private def getEnclosingSB(DCAstBracketNode node) {
+		var parent = node.parent
+		while (parent!==null) {
+			if (parent instanceof DCAstBracketNode && parent.linkedData instanceof StringBuilder) {
+				return parent.linkedData as StringBuilder
+			}
+			parent = parent.parent
+		}
+		
+		// return top level
+		return sb
+	}
+	
+	private def shouldCollectArguments(DCAstBracketNode node) {
+		val linkedObject = node.parent.linkedObject
+		
+		if (node.type==BracketType.CURLY) {
+			false
+		}
+		else if (linkedObject instanceof Operation) {
+			true
+		}
+		else if (linkedObject instanceof Message) {
+			true
+		}
+		else if (linkedObject instanceof Attribute) {
+			true
+		}
+		else if (linkedObject instanceof Port) {
+			true
+		}
+		else {
+			false
+		}
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/README.md b/plugins/org.eclipse.etrice.doc/README.md
index fed9a37c3..d5d6e615a 100644
--- a/plugins/org.eclipse.etrice.doc/README.md
+++ b/plugins/org.eclipse.etrice.doc/README.md
@@ -27,6 +27,7 @@ Eclipse Help
 ## HowTo Edit
 
 To update/publish everything run *make.xml*. Logs can be found in folder */tmp*.
+Prerequisite: Make at least a dummy change in featuremodel/etrice.featurizer to force code generation to folder */feature-gen*.
 
 ### FeatureModel
 
diff --git a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
index 40f574e03..38606a7f2 100644
--- a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
+++ b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
@@ -663,7 +663,7 @@ Feature CommunicationType
 			// explicit: eventdriven ProtocolClass EventdrivenProtocolClass {
 			incoming {
 				Message msg1() ["message without data"]
-				Message msg2(data: int32) ["message with data"]
+				Message msg2(int32) ["message with data"]
 			}
 			outgoing {
 				Message msg4()  ["eventdriven ProtocolClass can have message into two directions"]
@@ -672,7 +672,7 @@ Feature CommunicationType
 		
 		datadriven ProtocolClass DatadrivenProtocolClass {
 			incoming {
-				Message signal1 (data: int32) ["a datadriven message needs data"]
+				Message signal1 (int32) ["a datadriven message needs data"]
 			}
 			// datadriven ProtocolClass can only have incoming messages (signals)
 		}
@@ -697,11 +697,11 @@ Feature ProtocolClass
 		```room
 		ProtocolClass SimpleProtocolClass {
 			incoming {
-				Message msg1(data: int32}
+				Message msg1(int32}
 				Message msg2()
 			}
 			outgoing {
-				Message msg3(data: DataClass1}
+				Message msg3(DataClass1}
 				Message msg4()
 			}
 		}
@@ -717,13 +717,13 @@ Feature ProtocolClass
 			incoming {
 				// incoming means incoming for a regular port and outgoing for a conjugated port
 				Message message1() // message without data
-				Message message2(data: int32) // message with simple data
-				Message message3(data: DMessageData) // message with complex data (DataClass)
+				Message message2(int32) // message with simple data
+				Message message3(DMessageData) // message with complex data (DataClass)
 		
 			}
 			outgoing {
 			// outgoing means outgoing for a regular port and incoming for a conjugated port
-				Message message1(data: int32) // incoming and outgoing Messages can have the same name to enable symmetric protocols
+				Message message1(int32) // incoming and outgoing Messages can have the same name to enable symmetric protocols
 			}
 		}
 		
@@ -737,9 +737,9 @@ Feature ProtocolClass
 		datadriven ProtocolClass ProtocolClassData {
 			incoming {
 				// incoming means incoming for a regular port and outgoing for a conjugated port
-				Message value1(value: int32) // a datadriven message (signal) always needs data
-				Message value2(value: int16) // datadriven message with simple data
-				Message value3(value: DMessageData) // datadriven message with complex data (DataClass)
+				Message value1(int32) // a datadriven message (signal) always needs data
+				Message value2(int16) // datadriven message with simple data
+				Message value3(DMessageData) // datadriven message with complex data (DataClass)
 		
 			}
 			// no outgoing messages for datadriven ports allowed 
@@ -755,7 +755,7 @@ Feature ProtocolClass
 			usercode3 ''' '''
 			incoming {
 				Message messageName()
-				Message messageName(data: int32)
+				Message messageName(int32)
 			}
 			outgoing {
 				Message ...
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/config/_master.json b/plugins/org.eclipse.etrice.doc/online-doc/config/_master.json
index 45e346494..c70e3d18c 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/config/_master.json
+++ b/plugins/org.eclipse.etrice.doc/online-doc/config/_master.json
@@ -1,6 +1,6 @@
 {
     "title": "eTrice Documentation",
-    "version": "1.0",
+    "version": "2.x",
 	"xtext-langs" : {
 		"room" : "xtext_keyword_files/InternalRoom.tokens",
 		"etconfig" : "xtext_keyword_files/InternalConfig.tokens",
@@ -47,5 +47,11 @@
 	{
 		"name" : "Developer's Reference",
 		"url"  : "developers-reference.html"
-	}]
+	},
+	{
+		"name" : "Release Notes",
+		"url"  : "release-notes.html"
+	}
+	
+	]
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/config/release-notes.json b/plugins/org.eclipse.etrice.doc/online-doc/config/release-notes.json
new file mode 100644
index 000000000..d0e4c09b7
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/online-doc/config/release-notes.json
@@ -0,0 +1,6 @@
+{
+	"contentToc" : {
+		"parentName" : "Release Notes",
+		"toc" : "auto"
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
index fc3ce3315..00b915403 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
@@ -874,22 +874,24 @@ DataClass TCPConnectionData {
 
 **Example**:
 
-```room
-DataClass SimpleDataClass {
-	Attribute attribute1: uint16
-	Attribute attribute2: uint32
-}
+¦¦¦
+		```room
+		DataClass SimpleDataClass {
+			Attribute attribute1: uint16
+			Attribute attribute2: uint32
+		}
 
-DataClass DataClassExample {
-	Attribute attribute1: uint32
-	Attribute attribute2: SimpleDataClass
-	Attribute attribute3: voidType ref
-	
-	Operation operation1(param1: uint32, param2: uint16): boolean '''
-		return true;
-	'''
-}
-```
+		DataClass DataClassExample {
+			Attribute attribute1: uint32
+			Attribute attribute2: SimpleDataClass
+			Attribute attribute3: voidType ref
+			
+			Operation operation1(param1: uint32, param2: uint16): boolean '''
+				return true;
+			'''
+		}
+		```
+	¦¦¦
 
 ---
 
@@ -1178,25 +1180,27 @@ An ExternalType is used to make an target language type accessible in ROOM
 
 **Example**:
 
-```room
-// Include is needed when used (e.g. in ActorClassWithExternalType)
-ExternalType someStructType -> "struct FILE_HANDLE"
-
-ActorClass ActorClassWithExternalType{
-	Structure {
-		usercode1 '''
-			// #include <___.h> /* User includes here*/
-		'''
-		Attribute someHandle : someStructType ref // needs include
-	}
-	Behavior {
-		Operation operation1(param1: charPtr) '''
-			// external calls or casts may need includes
-			write(someHandle, param1);
-		'''
-	}
-}
-```
+¦¦¦
+		```room
+		// Include is needed when used (e.g. in ActorClassWithExternalType)
+		ExternalType someStructType -> "struct FILE_HANDLE"
+		
+		ActorClass ActorClassWithExternalType{
+			Structure {
+				usercode1 '''
+					// #include <___.h> /* User includes here*/
+				'''
+				Attribute someHandle : someStructType ref // needs include
+			}
+			Behavior {
+				Operation operation1(param1: charPtr) '''
+					// external calls or casts may need includes
+					write(someHandle, param1);
+				'''
+			}
+		}
+		```
+	¦¦¦
 
 ---
 
@@ -1266,43 +1270,45 @@ UserCode <==> non-accessible implicit late refinement
 
 **Example**:
 
-```room
-ActorClass ActorSubClass extends ActorBaseClass {
-	// inherits all elements from super type hierarchy
-}
-
-ActorClass ActorBaseClass {
-	Interface {
-		Port port1 : ProtocolBaseClass
-	}
-	Structure {
-		Attribute attribute1 : uint32
-	}
-	Behavior {
-		Operation operation1() '''
-			return;
-		'''
-	}
-}
-
-ProtocolClass ProtocolSubClass extends ProtocolBaseClass {
-	// inherits all elements from super type hierarchy
-}
-
-ProtocolClass ProtocolBaseClass {
-	incoming {
-		Message message1()
-	}
-}
-
-DataClass DataSubClass extends DataBaseClass {
-	// inherits all elements from super type hierarchy
-}
-
-DataClass DataBaseClass {
-	Attribute attribute1 : uint32
-}
-```
+¦¦¦
+		```room
+		ActorClass ActorSubClass extends ActorBaseClass {
+			// inherits all elements from super type hierarchy
+		}
+		
+		ActorClass ActorBaseClass {
+			Interface {
+				Port port1 : ProtocolBaseClass
+			}
+			Structure {
+				Attribute attribute1 : uint32
+			}
+			Behavior {
+				Operation operation1() '''
+					return;
+				'''
+			}
+		}
+		
+		ProtocolClass ProtocolSubClass extends ProtocolBaseClass {
+			// inherits all elements from super type hierarchy
+		}
+		
+		ProtocolClass ProtocolBaseClass {
+			incoming {
+				Message message1()
+			}
+		}
+		
+		DataClass DataSubClass extends DataBaseClass {
+			// inherits all elements from super type hierarchy
+		}
+		
+		DataClass DataBaseClass {
+			Attribute attribute1 : uint32
+		}
+		```
+		¦¦¦
 
 ---
 
@@ -1538,43 +1544,45 @@ Operations can be used to define a piece of reusable logic. The definition consi
 
 **Example**:
 
-```room
-import room.basic.types.* from "../../../org.eclipse.etrice.modellib.c/model/Types.room"
-
-DataClass DataClassWithOperation {
-	Attribute attribute1 : uint32
-	
-	Operation operation1(param1: uint32, param2: int32): boolean '''
-		return attribute1 > (param1 - param2);
-	'''
-}
-
-ActorClass ActorClassWithOperation {
-	Structure {
-		Attribute attribute1 : uint32
-	}
-	Behavior {
-		Operation operation1(param1: uint32, param2: int32): boolean '''
-			return attribute1 > (param1 - param2);
-		'''
-	}
-}
-
-ActorClass ActorClassWithOperation2 {
-	Structure {
-		usercode1 '''
-			// #include <___.h> /* User includes here */
-		'''
-		Attribute someHandle : voidType ref
-	}
-	Behavior {
-		Operation operation1(param1: charPtr) '''
-			// external calls or casts may need includes
-			write(someHandle, param1);
-		'''
-	}
-}
-```
+¦¦¦
+		```room
+		import room.basic.types.* from "../../../org.eclipse.etrice.modellib.c/model/Types.room"
+		
+		DataClass DataClassWithOperation {
+			Attribute attribute1 : uint32
+			
+			Operation operation1(param1: uint32, param2: int32): boolean '''
+				return attribute1 > (param1 - param2);
+			'''
+		}
+		
+		ActorClass ActorClassWithOperation {
+			Structure {
+				Attribute attribute1 : uint32
+			}
+			Behavior {
+				Operation operation1(param1: uint32, param2: int32): boolean '''
+					return attribute1 > (param1 - param2);
+				'''
+			}
+		}
+		
+		ActorClass ActorClassWithOperation2 {
+			Structure {
+				usercode1 '''
+					// #include <___.h> /* User includes here */
+				'''
+				Attribute someHandle : voidType ref
+			}
+			Behavior {
+				Operation operation1(param1: charPtr) '''
+					// external calls or casts may need includes
+					write(someHandle, param1);
+				'''
+			}
+		}
+		```
+	¦¦¦
 
 ---
 
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/introduction.md b/plugins/org.eclipse.etrice.doc/online-doc/content/introduction.md
index ae601454c..11ef05d0b 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/content/introduction.md
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/introduction.md
@@ -127,11 +127,11 @@ The basic elements of ROOM are the actors with their ports and protocols. The pr
 ```room
 ProtocolClass ProtocolClass1 {
 	incoming {
-		Message m1(data : int32)
+		Message m1(int32)
 		Message m2()
 	}
 	outgoing {
-		Message m3(data: DataClass1)
+		Message m3(DataClass1)
 		Message m4()
 	}
 }
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/release-notes.md b/plugins/org.eclipse.etrice.doc/online-doc/content/release-notes.md
new file mode 100644
index 000000000..7329afb66
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/release-notes.md
@@ -0,0 +1,26 @@
+
+Release Notes
+=========
+
+Noteworthy release changes are described here.
+
+2.0.0 Migration
+--------------------------
+
+<span class="label label-danger">Breaking Changes:</span> This release contains a breaking change to models used with previous versions.
+
+
+The name of the data for protocol messages is not longer used and is marked as deprecated. In state machines the message data is now named `transitionData`. Thus **all occurrences of the message data have to be renamed**. The changes to the model are depicted in the picture below:
+
+![image](images/600-TransitionDataMigration.png)
+
+eTrice provides a **migration action** which automatically applies the modification to a complete model file. But it is not guaranteed to find all instances of the message data, thus it may be necessary to apply the changes manually. The migration can be triggered via editor right click and hitting *Migration Transition Data Style* action.
+
+![image](images/600-TransitionDataMigrationAssitant.png)
+
+<span class="label label-info">Note:</span> The migration assistant relies on the message data names, thus the names should not be removed until you have fully migrated your project and all dependent projects.
+
+<br/>
+In addition eTrice now uses the so-called **Smart Strings** for user code. This is not a breaking change, but it is recommended to migrate to this new syntax also. Using the Transition Data migration action will automatically convert all affected user codes into Smart Strings. Further there is a dedicated migration action for the Smart Strings, see *Migrate to Smart Action Codes* above. Additionally there is a quickfix available:
+
+![image](images/600-DetailcodeMigration.png)
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/room-concepts.md b/plugins/org.eclipse.etrice.doc/online-doc/content/room-concepts.md
index 93e661f85..81ef0d486 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/content/room-concepts.md
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/room-concepts.md
@@ -179,11 +179,11 @@ Protocol classes have only textual notation. The example defines a protocol clas
 ```room
 ProtocolClass ProtocolClass1 {
 	incoming {
-		Message m1(data: int32}
+		Message m1(int32}
 		Message m2()
 	}
 	outgoing {
-		Message m3(data: DataClass1}
+		Message m3(DataClass1}
 		Message m4()
 	}
 }
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-DetailcodeMigration.png b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-DetailcodeMigration.png
new file mode 100644
index 000000000..4d81ea73a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-DetailcodeMigration.png
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigration.png b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigration.png
new file mode 100644
index 000000000..cf4544d97
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigration.png
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigrationAssitant.png b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigrationAssitant.png
new file mode 100644
index 000000000..02fa1d827
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/online-doc/static/images/600-TransitionDataMigrationAssitant.png
diff --git a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
index 841081ad3..ad2eb274b 100644
--- a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
+++ b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
@@ -1,44 +1,6 @@
 <!--  generated by featurizer  -->
 
 <contexts>
-<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
-<description>Mechanism to adjust the generation.</description>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
-</context>
-
-<context id="featureContextHelp_MSCLogging" title="MSCLogging">
-<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_DataLogging" title="DataLogging">
-<description>Runtime logger for data-driven Messages with primitive data.</description>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
-</context>
-
 <context id="featureContextHelp_TextualROOMEditor" title="TextualROOMEditor">
 <description>Textual model editor</description>
 <topic href="targets/eclipse-help/feature-reference.html#textualroomeditor" label="TextualROOMEditor"/>
@@ -106,12 +68,12 @@
 <description>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</description>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="Annotation"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="AnnotationType"/>
-<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="LogicalSystem"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="ActorClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="SubSystemClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="ProtocolClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataClass"/>
+<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
 </context>
 
 <context id="featureContextHelp_Inheritance" title="Inheritance">
@@ -363,4 +325,42 @@
 <topic href="targets/eclipse-help/feature-reference.html#spp" label="LayerConnection"/>
 <topic href="targets/eclipse-help/feature-reference.html#spp" label="ServiceImplementation"/>
 </context>
+
+<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
+<description>Mechanism to adjust the generation.</description>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
+</context>
+
+<context id="featureContextHelp_MSCLogging" title="MSCLogging">
+<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_DataLogging" title="DataLogging">
+<description>Runtime logger for data-driven Messages with primitive data.</description>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
+</context>
 </contexts>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
index 32884778e..f9d3225d4 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
@@ -17,7 +17,7 @@
 <div style="text-align:center;">
 <p><img src="images/logo/etrice-logo-interim.png"></p>
 <h1>eTrice Documentation</h1>
-<p>version 1.0</p>
+<p>version 2.x</p>
 </div>
 
 <!-- front page + toc--->
@@ -1323,6 +1323,26 @@
 
 
 
+<li><a href="release-notes.html">Release Notes</a>
+<ul>
+<li><a href="release-notes.html#2-0-0-migration">2.0.0 Migration</a></li>
+
+
+
+
+
+
+
+
+</ul>
+</li>
+
+
+
+
+
+
+
 </ul>
 
 </body>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
index 075486525..5f6cdf6cf 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
@@ -712,22 +712,20 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<pre><code class="room customHighlighted"><span class="keyword">DataClass</span> SimpleDataClass {
-	<span class="keyword">Attribute</span> attribute1: uint16
-	<span class="keyword">Attribute</span> attribute2: uint32
-}
+<p>¦¦¦<br> ```room&lt;br/&gt; DataClass SimpleDataClass {&lt;br/&gt; Attribute attribute1: uint16&lt;br/&gt; Attribute attribute2: uint32&lt;br/&gt; }&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;    DataClass DataClassExample {
+       Attribute attribute1: uint32
+       Attribute attribute2: SimpleDataClass
+       Attribute attribute3: voidType ref
 
-<span class="keyword">DataClass</span> DataClassExample {
-	<span class="keyword">Attribute</span> attribute1: uint32
-	<span class="keyword">Attribute</span> attribute2: SimpleDataClass
-	<span class="keyword">Attribute</span> attribute3: voidType <span class="keyword">ref</span>
-	
-	<span class="keyword">Operation</span> operation1(param1: uint32, param2: uint16): boolean <span class="string">'''
-		return true;
-	'''</span>
-}
-</code></pre>
-<hr>
+       Operation operation1(param1: uint32, param2: uint16): boolean &amp;#39;&amp;#39;&amp;#39;
+         return true;
+       &amp;#39;&amp;#39;&amp;#39;
+    }
+    ```
+¦¦¦
+
+</p><hr>
 <h3><a href="#datatype" name="datatype"></a>DataType</h3>
 <p>A DataType can take 4 forms and types data elements like an Attribute or Operation argument</p>
 <table style="vertical-align: middle;" class="table">
@@ -950,25 +948,25 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<pre><code class="room customHighlighted"><span class="comment">// Include is needed when used (e.g. in ActorClassWithExternalType)
-</span><span class="keyword">ExternalType</span> someStructType -&gt; <span class="string">"struct FILE_HANDLE"</span>
+<p>¦¦¦<br> ```room&lt;br/&gt; // Include is needed when used (e.g. in ActorClassWithExternalType)&lt;br/&gt; ExternalType someStructType -&amp;gt; &amp;ldquo;struct FILE_HANDLE&amp;rdquo;&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;    ActorClass ActorClassWithExternalType{
+       Structure {
+         usercode1 &amp;#39;&amp;#39;&amp;#39;
+          // #include &amp;lt;___.h&amp;gt; /* User includes here*/
+         &amp;#39;&amp;#39;&amp;#39;
+         Attribute someHandle : someStructType ref // needs include
+       }
+       Behavior {
+         Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
+          // external calls or casts may need includes
+          write(someHandle, param1);
+         &amp;#39;&amp;#39;&amp;#39;
+       }
+    }
+    ```
+¦¦¦
 
-<span class="keyword">ActorClass</span> ActorClassWithExternalType{
-	<span class="keyword">Structure</span> {
-		<span class="keyword">usercode1</span> <span class="string">'''
-			// #include &lt;___.h&gt; /* User includes here*/
-		'''</span>
-		<span class="keyword">Attribute</span> someHandle : someStructType <span class="keyword">ref</span> <span class="comment">// needs include
-</span>	}
-	<span class="keyword">Behavior</span> {
-		<span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
-			// external calls or casts may need includes
-			write(someHandle, param1);
-		'''</span>
-	}
-}
-</code></pre>
-<hr>
+</p><hr>
 <h3><a href="#inheritance" name="inheritance"></a>Inheritance</h3>
 <p>A class can specify a super class and inherits elements from the super class hierarchy</p>
 <p>When a ROOM class specifies a super class, it generally inherits all elements and properties.<br>In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.<br>Refinement is used in most cases (e.g. StateMachine) and realizes an extension of the overridden elements.<br>In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.<br>Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.</p>
@@ -1008,43 +1006,42 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ActorSubClass <span class="keyword">extends</span> ActorBaseClass {
-	<span class="comment">// inherits all elements from super type hierarchy
-</span>}
+<p>¦¦¦<br> ```room&lt;br/&gt; ActorClass ActorSubClass extends ActorBaseClass {&lt;br/&gt; // inherits all elements from super type hierarchy&lt;br/&gt; }&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;    ActorClass ActorBaseClass {
+       Interface {
+         Port port1 : ProtocolBaseClass
+       }
+       Structure {
+         Attribute attribute1 : uint32
+       }
+       Behavior {
+         Operation operation1() &amp;#39;&amp;#39;&amp;#39;
+          return;
+         &amp;#39;&amp;#39;&amp;#39;
+       }
+    }
 
-<span class="keyword">ActorClass</span> ActorBaseClass {
-	<span class="keyword">Interface</span> {
-		<span class="keyword">Port</span> port1 : ProtocolBaseClass
-	}
-	<span class="keyword">Structure</span> {
-		<span class="keyword">Attribute</span> attribute1 : uint32
-	}
-	<span class="keyword">Behavior</span> {
-		<span class="keyword">Operation</span> operation1() <span class="string">'''
-			return;
-		'''</span>
-	}
-}
+    ProtocolClass ProtocolSubClass extends ProtocolBaseClass {
+       // inherits all elements from super type hierarchy
+    }
 
-<span class="keyword">ProtocolClass</span> ProtocolSubClass <span class="keyword">extends</span> ProtocolBaseClass {
-	<span class="comment">// inherits all elements from super type hierarchy
-</span>}
+    ProtocolClass ProtocolBaseClass {
+       incoming {
+         Message message1()
+       }
+    }
 
-<span class="keyword">ProtocolClass</span> ProtocolBaseClass {
-	<span class="keyword">incoming</span> {
-		<span class="keyword">Message</span> message1()
-	}
-}
+    DataClass DataSubClass extends DataBaseClass {
+       // inherits all elements from super type hierarchy
+    }
 
-<span class="keyword">DataClass</span> DataSubClass <span class="keyword">extends</span> DataBaseClass {
-	<span class="comment">// inherits all elements from super type hierarchy
-</span>}
+    DataClass DataBaseClass {
+       Attribute attribute1 : uint32
+    }
+    ```
+    ¦¦¦
 
-<span class="keyword">DataClass</span> DataBaseClass {
-	<span class="keyword">Attribute</span> attribute1 : uint32
-}
-</code></pre>
-<hr>
+</p><hr>
 <h3><a href="#internalendport" name="internalendport"></a>InternalEndPort</h3>
 <p>A InternalEndPort is an local Port, that is declared in the internal interface of an ActorClass</p>
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> InternalEndPortExample {
@@ -1231,43 +1228,44 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<pre><code class="room customHighlighted"><span class="keyword">import</span> room.basic.types.* <span class="keyword">from</span> <span class="string">"../../../org.eclipse.etrice.modellib.c/model/Types.room"</span>
+<p>¦¦¦<br> ```room&lt;br/&gt; import room.basic.types.* from &amp;ldquo;../../../org.eclipse.etrice.modellib.c/model/Types.room&amp;rdquo;&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;    DataClass DataClassWithOperation {
+       Attribute attribute1 : uint32
 
-<span class="keyword">DataClass</span> DataClassWithOperation {
-	<span class="keyword">Attribute</span> attribute1 : uint32
-	
-	<span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
-		return attribute1 &gt; (param1 - param2);
-	'''</span>
-}
+       Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
+         return attribute1 &amp;gt; (param1 - param2);
+       &amp;#39;&amp;#39;&amp;#39;
+    }
 
-<span class="keyword">ActorClass</span> ActorClassWithOperation {
-	<span class="keyword">Structure</span> {
-		<span class="keyword">Attribute</span> attribute1 : uint32
-	}
-	<span class="keyword">Behavior</span> {
-		<span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
-			return attribute1 &gt; (param1 - param2);
-		'''</span>
-	}
-}
+    ActorClass ActorClassWithOperation {
+       Structure {
+         Attribute attribute1 : uint32
+       }
+       Behavior {
+         Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
+          return attribute1 &amp;gt; (param1 - param2);
+         &amp;#39;&amp;#39;&amp;#39;
+       }
+    }
 
-<span class="keyword">ActorClass</span> ActorClassWithOperation2 {
-	<span class="keyword">Structure</span> {
-		<span class="keyword">usercode1</span> <span class="string">'''
-			// #include &lt;___.h&gt; /* User includes here */
-		'''</span>
-		<span class="keyword">Attribute</span> someHandle : voidType <span class="keyword">ref</span>
-	}
-	<span class="keyword">Behavior</span> {
-		<span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
-			// external calls or casts may need includes
-			write(someHandle, param1);
-		'''</span>
-	}
-}
-</code></pre>
-<hr>
+    ActorClass ActorClassWithOperation2 {
+       Structure {
+         usercode1 &amp;#39;&amp;#39;&amp;#39;
+          // #include &amp;lt;___.h&amp;gt; /* User includes here */
+         &amp;#39;&amp;#39;&amp;#39;
+         Attribute someHandle : voidType ref
+       }
+       Behavior {
+         Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
+          // external calls or casts may need includes
+          write(someHandle, param1);
+         &amp;#39;&amp;#39;&amp;#39;
+       }
+    }
+    ```
+¦¦¦
+
+</p><hr>
 <h3><a href="#port" name="port"></a>Port</h3>
 <p>A Port is an instance of a ProtocolClass and the interface for an ActorClass</p>
 <p>Once a ProtocolClass has been created, it can be used to define actor interfaces. This is accomplished by means of Ports.<br>A Port is a declaration that the set of messages defined by its ProtocolClass is now part of the actor’s interface.<br>It provides strong decoupling of ActorClasses from each other, thus enabling easy testability, reusability and deployment of actors to different threads or nodes.</p>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-DetailcodeMigration.png b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-DetailcodeMigration.png
new file mode 100644
index 000000000..4d81ea73a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-DetailcodeMigration.png
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigration.png b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigration.png
new file mode 100644
index 000000000..cf4544d97
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigration.png
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigrationAssitant.png b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigrationAssitant.png
new file mode 100644
index 000000000..02fa1d827
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/images/600-TransitionDataMigrationAssitant.png
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/introduction.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/introduction.html
index 6f6d6073e..0324f2b6e 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/introduction.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/introduction.html
@@ -128,11 +128,11 @@
 			<td><p><img src="images/040-ActorClass.png" alt="image"></p></td>
 			<td><pre><code class="room customHighlighted"><span class="keyword">ProtocolClass</span> ProtocolClass1 {
 	<span class="keyword">incoming</span> {
-		<span class="keyword">Message</span> m1(data : int32)
+		<span class="keyword">Message</span> m1(int32)
 		<span class="keyword">Message</span> m2()
 	}
 	<span class="keyword">outgoing</span> {
-		<span class="keyword">Message</span> m3(data: DataClass1)
+		<span class="keyword">Message</span> m3(DataClass1)
 		<span class="keyword">Message</span> m4()
 	}
 }
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/release-notes.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/release-notes.html
new file mode 100644
index 000000000..de7f03d58
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/release-notes.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
+<title>eTrice Documentation</title>
+
+<link rel="stylesheet" type="text/css" href="css/book.css"/>
+<link rel="stylesheet" type="text/css" href="css/custom-common.css"/>
+
+</head>
+<body>
+
+
+
+	
+
+<h1><a href="#release-notes" name="release-notes"></a>Release Notes</h1>
+<p>Noteworthy release changes are described here.</p>
+<h2><a href="#2-0-0-migration" name="2-0-0-migration"></a>2.0.0 Migration</h2>
+<p><span class="label label-danger">Breaking Changes:</span> This release contains a breaking change to models used with previous versions.</p>
+<p>The name of the data for protocol messages is not longer used and is marked as deprecated. In state machines the message data is now named <code>transitionData</code>. Thus <strong>all occurrences of the message data have to be renamed</strong>. The changes to the model are depicted in the picture below:</p>
+<p><img src="images/600-TransitionDataMigration.png" alt="image"></p>
+<p>eTrice provides a <strong>migration action</strong> which automatically applies the modification to a complete model file. But it is not guaranteed to find all instances of the message data, thus it may be necessary to apply the changes manually. The migration can be triggered via editor right click and hitting <em>Migration Transition Data Style</em> action.</p>
+<p><img src="images/600-TransitionDataMigrationAssitant.png" alt="image"></p>
+<p><span class="label label-info">Note:</span> The migration assistant relies on the message data names, thus the names should not be removed until you have fully migrated your project and all dependent projects.</p>
+<br>
+<p>In addition eTrice now uses the so-called <strong>Smart Strings</strong> for user code. This is not a breaking change, but it is recommended to migrate to this new syntax also. Using the Transition Data migration action will automatically convert all affected user codes into Smart Strings. Further there is a dedicated migration action for the Smart Strings, see <em>Migrate to Smart Action Codes</em> above. Additionally there is a quickfix available:</p>
+<p><img src="images/600-DetailcodeMigration.png" alt="image"></p>
+
+</body>
+</html>
+
+
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
index abe0d2837..e6ec50cc0 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
@@ -152,11 +152,11 @@
 <p>Protocol classes have only textual notation. The example defines a protocol class with 2 incoming and two outgoing messages. Messages can have data attached. The data can be of a primitive type (e.g. int32, float64, …) or a data class.</p>
 <pre><code class="room customHighlighted"><span class="keyword">ProtocolClass</span> ProtocolClass1 {
 	<span class="keyword">incoming</span> {
-		<span class="keyword">Message</span> m1(data: int32}
+		<span class="keyword">Message</span> m1(int32}
 		<span class="keyword">Message</span> m2()
 	}
 	<span class="keyword">outgoing</span> {
-		<span class="keyword">Message</span> m3(data: DataClass1}
+		<span class="keyword">Message</span> m3(DataClass1}
 		<span class="keyword">Message</span> m4()
 	}
 }
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
index 02f963047..df79d8ddd 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
@@ -168,5 +168,8 @@
 </topic>
 </topic>
 </topic>
+</topic><topic href="targets/eclipse-help/release-notes.html" label="Release Notes">
+<topic href="targets/eclipse-help/release-notes.html#2-0-0-migration" label="2.0.0 Migration">
+</topic>
 </topic>
 </toc>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Binding.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Binding.html
index 33b926897..24ebfcdef 100644
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Binding.html
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Binding.html
@@ -1,5 +1,5 @@
 <!--  generated by featurizer  -->
 <p>A Binding connects two Ports with each other</p>
-<pre><code class=room customHighlighted><span class=keyword>Binding</span> port1 <span class=keyword>and</span> <span class=keyword>actorRef</span>.port2
+<pre><code class=room customHighlighted><span class=keyword>Binding</span> port1 <span class=keyword>and</span> actorRef.port2
 <span class=keyword>Binding</span> actorRef1.port1 <span class=keyword>and</span> actorRef2.port2
 </code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/MarkdownCheatsheet.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/MarkdownCheatsheet.html
deleted file mode 100644
index 433d28835..000000000
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/MarkdownCheatsheet.html
+++ /dev/null
@@ -1,393 +0,0 @@
-<!--  generated by featurizer  -->
-<p>&rsquo;&rsquo;&rsquo;&rsquo;&rsquo;&rsquo;</p>
-<p>&rsquo;&rsquo;&rsquo;<br/> Taken from <a href="https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet">https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet</a></p>
-<pre><code>    ---
-
-    This is intended as a quick reference and showcase. For more complete info, see [John Gruber&#39;s original spec](http://daringfireball.net/projects/markdown/) and the [Github-flavored Markdown info page](http://github.github.com/github-flavored-markdown/).
-
-    Note that there is also a [Cheatsheet specific to Markdown Here](./Markdown-Here-Cheatsheet) if that&#39;s what you&#39;re looking for. You can also check out [more Markdown tools](./Other-Markdown-Tools).
-
-    ##### Table of Contents  
-    [Headers](#headers)  
-    [Emphasis](#emphasis)  
-    [Lists](#lists)  
-    [Links](#links)  
-    [Images](#images)  
-    [Code and Syntax Highlighting](#code)  
-    [Tables](#tables)  
-    [Blockquotes](#blockquotes)  
-    [Inline HTML](#html)  
-    [Horizontal Rule](#hr)  
-    [Line Breaks](#lines)  
-    [Youtube videos](#videos)  
-
-    &lt;a name=&quot;headers&quot;/&gt;
-    ## Headers
-
-    ```no-highlight
-    # H1
-    ## H2
-    ### H3
-    #### H4
-    ##### H5
-    ###### H6
-
-    Alternatively, for H1 and H2, an underline-ish style:
-
-    Alt-H1
-    ======
-
-    Alt-H2
-    ------
-    ```
-
-    # H1
-    ## H2
-    ### H3
-    #### H4
-    ##### H5
-    ###### H6
-
-    Alternatively, for H1 and H2, an underline-ish style:
-
-    Alt-H1
-    ======
-
-    Alt-H2
-    ------
-
-    &lt;a name=&quot;emphasis&quot;/&gt;
-    ## Emphasis
-
-    ```no-highlight
-    Emphasis, aka italics, with *asterisks* or _underscores_.
-
-    Strong emphasis, aka bold, with **asterisks** or __underscores__.
-
-    Combined emphasis with **asterisks and _underscores_**.
-
-    Strikethrough uses two tildes. ~~Scratch this.~~
-    ```
-
-    Emphasis, aka italics, with *asterisks* or _underscores_.
-
-    Strong emphasis, aka bold, with **asterisks** or __underscores__.
-
-    Combined emphasis with **asterisks and _underscores_**.
-
-    Strikethrough uses two tildes. ~~Scratch this.~~
-
-
-    &lt;a name=&quot;lists&quot;/&gt;
-    ## Lists
-
-    (In this example, leading and trailing spaces are shown with with dots: â‹…)
-
-    ```no-highlight
-    1. First ordered list item
-    2. Another item
-      * Unordered sub-list. 
-    1. Actual numbers don&#39;t matter, just that it&#39;s a number
-      1. Ordered sub-list
-    4. And another item.
-
-       You can have properly indented paragraphs within list items. Notice the blank line above, and the leading spaces (at least one, but we&#39;ll use three here to also align the raw Markdown).
-
-       To have a line break without a paragraph, you will need to use two trailing spaces.â‹…â‹…
-       Note that this line is separate, but within the same paragraph.â‹…â‹…
-       (This is contrary to the typical GFM line break behaviour, where trailing spaces are not required.)
-
-    * Unordered list can use asterisks
-    - Or minuses
-    + Or pluses
-    ```
-
-    1. First ordered list item
-    2. Another item
-      * Unordered sub-list. 
-    1. Actual numbers don&#39;t matter, just that it&#39;s a number
-      1. Ordered sub-list
-    4. And another item.
-
-       You can have properly indented paragraphs within list items. Notice the blank line above, and the leading spaces (at least one, but we&#39;ll use three here to also align the raw Markdown).
-
-       To have a line break without a paragraph, you will need to use two trailing spaces.  
-       Note that this line is separate, but within the same paragraph.  
-       (This is contrary to the typical GFM line break behaviour, where trailing spaces are not required.)
-
-    * Unordered list can use asterisks
-    - Or minuses
-    + Or pluses
-
-    &lt;a name=&quot;links&quot;/&gt;
-    ## Links
-
-    There are two ways to create links.
-
-    ```no-highlight
-    [I&#39;m an inline-style link](https://www.google.com)
-
-    [I&#39;m an inline-style link with title](https://www.google.com &quot;Google&#39;s Homepage&quot;)
-
-    [I&#39;m a reference-style link][Arbitrary case-insensitive reference text]
-
-    [I&#39;m a relative reference to a repository file](../blob/master/LICENSE)
-
-    [You can use numbers for reference-style link definitions][1]
-
-    Or leave it empty and use the [link text itself]
-
-    Some text to show that the reference links can follow later.
-
-    [arbitrary case-insensitive reference text]: https://www.mozilla.org
-    [1]: http://slashdot.org
-    [link text itself]: http://www.reddit.com
-    ```
-
-    [I&#39;m an inline-style link](https://www.google.com)
-
-    [I&#39;m an inline-style link with title](https://www.google.com &quot;Google&#39;s Homepage&quot;)
-
-    [I&#39;m a reference-style link][Arbitrary case-insensitive reference text]
-
-    [I&#39;m a relative reference to a repository file](../blob/master/LICENSE)
-
-    [You can use numbers for reference-style link definitions][1]
-
-    Or leave it empty and use the [link text itself]
-
-    Some text to show that the reference links can follow later.
-
-    [arbitrary case-insensitive reference text]: https://www.mozilla.org
-    [1]: http://slashdot.org
-    [link text itself]: http://www.reddit.com
-
-    &lt;a name=&quot;images&quot;/&gt;
-    ## Images
-
-    ```no-highlight
-    Here&#39;s our logo (hover to see the title text):
-
-    Inline-style: 
-    ![alt text](https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png &quot;Logo Title Text 1&quot;)
-
-    Reference-style: 
-    ![alt text][logo]
-
-    [logo]: https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png &quot;Logo Title Text 2&quot;
-    ```
-
-    Here&#39;s our logo (hover to see the title text):
-
-    Inline-style: 
-    ![alt text](https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png &quot;Logo Title Text 1&quot;)
-
-    Reference-style: 
-    ![alt text][logo]
-
-    [logo]: https://github.com/adam-p/markdown-here/raw/master/src/common/images/icon48.png &quot;Logo Title Text 2&quot;
-
-    &lt;a name=&quot;code&quot;/&gt;
-    ## Code and Syntax Highlighting
-
-    Code blocks are part of the Markdown spec, but syntax highlighting isn&#39;t. However, many renderers -- like Github&#39;s and *Markdown Here* -- support syntax highlighting. Which languages are supported and how those language names should be written will vary from renderer to renderer. *Markdown Here* supports highlighting for dozens of languages (and not-really-languages, like diffs and HTTP headers); to see the complete list, and how to write the language names, see the [highlight.js demo page](http://softwaremaniacs.org/media/soft/highlight/test.html).
-
-    ```no-highlight
-    Inline `code` has `back-ticks around` it.
-    ```
-
-    Inline `code` has `back-ticks around` it.
-
-    Blocks of code are either fenced by lines with three back-ticks &lt;code&gt;```&lt;/code&gt;, or are indented with four spaces. I recommend only using the fenced code blocks -- they&#39;re easier and only they support syntax highlighting.
-
-    &lt;pre lang=&quot;no-highlight&quot;&gt;&lt;code&gt;```javascript
-    var s = &quot;JavaScript syntax highlighting&quot;;
-    alert(s);
-    ```
-
-    ```python
-    s = &quot;Python syntax highlighting&quot;
-    print s
-    ```
-
-    ```
-    No language indicated, so no syntax highlighting. 
-    But let&#39;s throw in a &amp;lt;b&amp;gt;tag&amp;lt;/b&amp;gt;.
-    ```
-    &lt;/code&gt;&lt;/pre&gt;
-
-
-
-    ```javascript
-    var s = &quot;JavaScript syntax highlighting&quot;;
-    alert(s);
-    ```
-
-    ```python
-    s = &quot;Python syntax highlighting&quot;
-    print s
-    ```
-
-    ```
-    No language indicated, so no syntax highlighting in Markdown Here (varies on Github). 
-    But let&#39;s throw in a &lt;b&gt;tag&lt;/b&gt;.
-    ```
-
-
-    &lt;a name=&quot;tables&quot;/&gt;
-    ## Tables
-
-    Tables aren&#39;t part of the core Markdown spec, but they are part of GFM and *Markdown Here* supports them. They are an easy way of adding tables to your email -- a task that would otherwise require copy-pasting from another application.
-
-    ```no-highlight
-    Colons can be used to align columns.
-
-    | Tables        | Are           | Cool  |
-    | ------------- |:-------------:| -----:|
-    | col 3 is      | right-aligned | $1600 |
-    | col 2 is      | centered      |   $12 |
-    | zebra stripes | are neat      |    $1 |
-
-    The outer pipes (|) are optional, and you don&#39;t need to make the raw Markdown line up prettily. You can also use inline Markdown.
-
-    Markdown | Less | Pretty
-    --- | --- | ---
-    *Still* | `renders` | **nicely**
-    1 | 2 | 3
-    ```
-
-    Colons can be used to align columns.
-
-    | Tables        | Are           | Cool |
-    | ------------- |:-------------:| -----:|
-    | col 3 is      | right-aligned | $1600 |
-    | col 2 is      | centered      |   $12 |
-    | zebra stripes | are neat      |    $1 |
-
-    The outer pipes (|) are optional, and you don&#39;t need to make the raw Markdown line up prettily. You can also use inline Markdown.
-
-    Markdown | Less | Pretty
-    --- | --- | ---
-    *Still* | `renders` | **nicely**
-    1 | 2 | 3
-
-    &lt;a name=&quot;blockquotes&quot;/&gt;
-    ## Blockquotes
-
-    ```no-highlight
-    &gt; Blockquotes are very handy in email to emulate reply text.
-    &gt; This line is part of the same quote.
-
-    Quote break.
-
-    &gt; This is a very long line that will still be quoted properly when it wraps. Oh boy let&#39;s keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can *put* **Markdown** into a blockquote. 
-    ```
-
-    &gt; Blockquotes are very handy in email to emulate reply text.
-    &gt; This line is part of the same quote.
-
-    Quote break.
-
-    &gt; This is a very long line that will still be quoted properly when it wraps. Oh boy let&#39;s keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can *put* **Markdown** into a blockquote. 
-
-    &lt;a name=&quot;html&quot;/&gt;
-    ## Inline HTML
-
-    You can also use raw HTML in your Markdown, and it&#39;ll mostly work pretty well. 
-
-    ```no-highlight
-    &lt;dl&gt;
-      &lt;dt&gt;Definition list&lt;/dt&gt;
-      &lt;dd&gt;Is something people use sometimes.&lt;/dd&gt;
-
-      &lt;dt&gt;Markdown in HTML&lt;/dt&gt;
-      &lt;dd&gt;Does *not* work **very** well. Use HTML &lt;em&gt;tags&lt;/em&gt;.&lt;/dd&gt;
-    &lt;/dl&gt;
-    ```
-
-    &lt;dl&gt;
-      &lt;dt&gt;Definition list&lt;/dt&gt;
-      &lt;dd&gt;Is something people use sometimes.&lt;/dd&gt;
-
-      &lt;dt&gt;Markdown in HTML&lt;/dt&gt;
-      &lt;dd&gt;Does *not* work **very** well. Use HTML &lt;em&gt;tags&lt;/em&gt;.&lt;/dd&gt;
-    &lt;/dl&gt;
-
-    &lt;a name=&quot;hr&quot;/&gt;
-    ## Horizontal Rule
-
-    ```
-    Three or more...
-
-    ---
-
-    Hyphens
-
-    ***
-
-    Asterisks
-
-    ___
-
-    Underscores
-    ```
-
-    Three or more...
-
-    ---
-
-    Hyphens
-
-    ***
-
-    Asterisks
-
-    ___
-
-    Underscores
-
-    &lt;a name=&quot;lines&quot;/&gt;
-    ## Line Breaks
-
-    My basic recommendation for learning how line breaks work is to experiment and discover -- hit &amp;lt;Enter&amp;gt; once (i.e., insert one newline), then hit it twice (i.e., insert two newlines), see what happens. You&#39;ll soon learn to get what you want. &quot;Markdown Toggle&quot; is your friend. 
-
-    Here are some things to try out:
-
-    ```
-    Here&#39;s a line for us to start with.
-
-    This line is separated from the one above by two newlines, so it will be a *separate paragraph*.
-
-    This line is also a separate paragraph, but...
-    This line is only separated by a single newline, so it&#39;s a separate line in the *same paragraph*.
-    ```
-
-    Here&#39;s a line for us to start with.
-
-    This line is separated from the one above by two newlines, so it will be a *separate paragraph*.
-
-    This line is also begins a separate paragraph, but...  
-    This line is only separated by a single newline, so it&#39;s a separate line in the *same paragraph*.
-
-    (Technical note: *Markdown Here* uses GFM line breaks, so there&#39;s no need to use MD&#39;s two-space line breaks.)
-
-    &lt;a name=&quot;videos&quot;/&gt;
-    ## Youtube videos
-
-    They can&#39;t be added directly but you can add an image with a link to the video like this:
-
-    ```no-highlight
-    &lt;a href=&quot;http://www.youtube.com/watch?feature=player_embedded&amp;v=YOUTUBE_VIDEO_ID_HERE
-    &quot; target=&quot;_blank&quot;&gt;&lt;img src=&quot;http://img.youtube.com/vi/YOUTUBE_VIDEO_ID_HERE/0.jpg&quot; 
-    alt=&quot;IMAGE ALT TEXT HERE&quot; width=&quot;240&quot; height=&quot;180&quot; border=&quot;10&quot; /&gt;&lt;/a&gt;
-    ```
-
-    Or, in pure Markdown, but losing the image sizing and border:
-
-    ```no-highlight
-    [![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/YOUTUBE_VIDEO_ID_HERE/0.jpg)](http://www.youtube.com/watch?v=YOUTUBE_VIDEO_ID_HERE)
-    ```
-
-    Referencing a bug by #bugID in your git commit links it to the slip. For example #1. 
-&#39;&#39;&#39;
-</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ProtocolClass.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ProtocolClass.html
index ab55f30a8..c58550412 100644
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ProtocolClass.html
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ProtocolClass.html
@@ -7,7 +7,7 @@
 	<span class=keyword>usercode3</span> <span class=string>&#39;&#39;&#39; &#39;&#39;&#39;</span>
 	<span class=keyword>incoming</span> {
 		<span class=keyword>Message</span> messageName()
-		<span class=keyword>Message</span> messageName(data: int32)
+		<span class=keyword>Message</span> messageName(int32)
 	}
 	<span class=keyword>outgoing</span> {
 		<span class=keyword>Message</span> ...
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SynatxColoring.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SynatxColoring.html
deleted file mode 100644
index 57b66f1c7..000000000
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SynatxColoring.html
+++ /dev/null
@@ -1,202 +0,0 @@
-<!--  generated by featurizer  -->
-<p>&rsquo;&rsquo;&rsquo;&rsquo;&rsquo;&rsquo;</p>
-<p>&rsquo;&rsquo;&rsquo;<br/> ## room</p>
-<pre><code>    ```room
-    import room.basic.types.* from &quot;../../../org.eclipse.etrice.modellib.c/model/Types.room&quot;
-
-    ActorClass InternalEndPortExample {
-       Structure {
-         Port internalEndPort : PSimpleProtocol
-         ActorRef actorRef1 : SimpleActorClass1
-
-         // internalEndPort lives &#39;local&#39; 
-         // and thus needs a Binding to port of an ActorRef
-         Binding internalEndPort and actorRef1.externalPort
-       }
-       Behavior {
-         // send/receive messages from internalEndPorts
-       }
-    }
-
-    ActorClass Receiver {
-         Interface {
-          Port sender: PingPongProtocol
-         }
-         Structure {
-          external Port sender
-          SAP timing : PTimer
-         }
-         Behavior {
-          StateMachine {
-              Transition init: initial -&gt; WaitingForPing { }
-              Transition tr0: WaitingForPing -&gt; WaitingForAWhile {
-                 triggers {
-                   &lt;ping: sender&gt;
-                 }
-              }
-              Transition tr1: WaitingForAWhile -&gt; SentPong {
-                 triggers {
-                   &lt;timeout: timing&gt;
-                 }
-              }
-              State WaitingForPing
-              State SentPong {
-                 entry {
-                   &quot;sender.pong();&quot;
-                 }
-              }
-              State WaitingForAWhile {
-                 entry {
-                   &quot;timing.startTimeout(1000);&quot;
-                 }
-              }
-          }
-         }
-       }
-
-    // eventdriven ProtocolClass (asynchronous message passing, bidirectional)
-    eventdriven ProtocolClass ProtocolClassEvt {
-       // ProtocolClass ProtocolClassEvt { // same like above because eventdriven is default 
-       incoming {
-         // incoming means incoming for a regular port and outging for a conjugated port
-         Message message1() // message without data
-         Message message2(data: int32) // message with simple data
-         Message message3(data: DMessageData) // message with complex data (DataClass)
-
-       }
-       outgoing {
-       // outgoing means outging for a regular port and incoming for a conjugated port
-         Message message1(data: int32) // incoming and outgoing Messages can have the same name to enable symmetric protocols
-       }
-    }
-
-    // DataClass for sending complex data via message
-    DataClass DMessageData {
-       Attribute SomeData: int16
-       Attribute SomeMoreData: int32
-    }
-    ```
-
-    ## etMap
-
-    ```etmap
-    MappingModel PingPongMapping {
-       import PingPong_Model.* from &quot;PingPong.room&quot;
-       import GenericPhysicalModel.* from &quot;GenericPhysical.etphys&quot;
-
-       Mapping LogSys -&gt; PhysSys1 {
-         SubSystemMapping subSystemRef -&gt; nodeRef1 {
-          ThreadMapping defaultThread -&gt; PhysicalThread1
-         }
-       }
-
-    }
-    ```
-
-    ## etPhys
-
-    ```etphys
-    PhysicalModel GenericPhysicalModel {
-
-       PhysicalSystem PhysSys1 {
-         NodeRef nodeRef1 : NodeClass1
-       }
-
-       NodeClass NodeClass1 {
-         runtime = RuntimeClass1
-         priomin = -10
-         priomax = 10
-
-         DefaultThread PhysicalThread1 {
-          execmode = mixed
-          interval = 100ms
-          prio = 0
-          stacksize = 1024
-          msgblocksize = 64
-          msgpoolsize = 100
-         }
-       }
-
-       RuntimeClass RuntimeClass1 {
-         model = multiThreaded
-       } 
-
-    } 
-    ```
-
-    ## config
-
-    ```config
-    /*******************************************************************************
-     * Copyright (c) 2012 protos software gmbh (http://www.protos.de).
-     * All rights reserved. This program and the accompanying materials
-     * are made available under the terms of the Eclipse Public License v1.0
-     * which accompanies this distribution, and is available at
-     * http://www.eclipse.org/legal/epl-v10.html
-     * 
-     * CONTRIBUTORS:
-     *        Thomas Schuetz (initial contribution)
-     * 
-     *******************************************************************************/
-    ConfigModel trafficlight.example.config {
-
-       import TrafficLight_Model.* from &quot;TrafficLight.room&quot;
-
-       ActorInstanceConfig LSTraffic/mainSS/application/pedestrianLight {
-         Attr ipConfig{
-          Attr IPAddr=&quot;localhost&quot;
-          Attr TcpPort=4443
-         }
-       } 
-    }
-    ```
-
-    &lt;pre lang=&quot;no-highlight&quot;&gt;&lt;code&gt; 
-    ```
-    &quot;no highlighting&quot;  /* comment */
-    // nop 
-    ```
-
-    ```no-highlight
-    &quot;no highlighting&quot;  /* comment */
-    // nop 
-    ```
-    &lt;/code&gt;&lt;/pre&gt;
-
-    ```
-    &quot;no highlighting&quot;  /* comment */
-    // nop 
-    ```
-
-    ```no-highlight
-    &quot;no highlighting&quot;  /* comment */
-    // nop 
-    ```
-
-    ## TODO
-
-    Syntax highlighting for other languages like c:       
-
-    ```c
-    void etMessageQueue_push(etMessageQueue* self, etMessage* msg){
-       /* TODO: optimize queue for concurrent push / pop */
-       ET_MSC_LOGGER_SYNC_ENTRY(&quot;etMessageQueue&quot;, &quot;push&quot;)
-       if (self-&gt;first == NULL) {
-         /*no message in queue*/
-         self-&gt;first = self-&gt;last = msg;
-       }
-       else {
-         /*at least one message in queue*/
-         self-&gt;last-&gt;next = msg;
-         self-&gt;last = msg;
-       }
-       msg-&gt;next = NULL; /*TODO: optimization: this line could be removed if we assume that all messages are initialized*/
-
-       if (++self-&gt;size &gt; self-&gt;highWaterMark)
-         self-&gt;highWaterMark++;
-
-       ET_MSC_LOGGER_SYNC_EXIT
-    }
-    ```
-&#39;&#39;&#39;
-</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TemplateFeature.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TemplateFeature.html
deleted file mode 100644
index b4e3a87fb..000000000
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TemplateFeature.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<!--  generated by featurizer  -->
-<p>&rsquo;&lsquo;&lsquo;Plain text: A ProtocolClass defines the Interface of a Port. It specifies the exchanged messages and data.&rsquo;&rsquo;&rsquo;</p>
-<p>&rsquo;&rsquo;&lsquo;<br/> Markdown (GMF): Hover help<br/> &rsquo;&rsquo;&rsquo;</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.expressions.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.expressions.ui/META-INF/MANIFEST.MF
index b8cb3167d..ab278b50f 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.expressions.ui/META-INF/MANIFEST.MF
@@ -10,8 +10,10 @@ Require-Bundle: org.eclipse.jface.text,
  org.eclipse.xtend.lib.macro,
  org.eclipse.xtext.ui,
  org.eclipse.etrice.core.room,
- org.eclipse.etrice.core.fsm
+ org.eclipse.etrice.core.fsm,
+ org.eclipse.etrice.generator
 Export-Package: org.eclipse.etrice.expressions.detailcode,
  org.eclipse.etrice.expressions.ui.contentassist,
  org.eclipse.etrice.expressions.ui.highlight
+Bundle-Vendor: Eclipse eTrice
 
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DefaultDetailExpressionProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DefaultDetailExpressionProvider.xtend
deleted file mode 100644
index b47178b64..000000000
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DefaultDetailExpressionProvider.xtend
+++ /dev/null
@@ -1,98 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Juergen Haug (initial contribution)
- * 
- *******************************************************************************/
-package org.eclipse.etrice.expressions.detailcode
-
-import java.util.List
-import org.eclipse.etrice.core.room.Attribute
-import org.eclipse.etrice.core.room.DataClass
-import org.eclipse.etrice.core.room.InterfaceItem
-import org.eclipse.etrice.core.room.Port
-import org.eclipse.etrice.core.room.SAP
-import org.eclipse.etrice.core.room.SPP
-import org.eclipse.etrice.expressions.detailcode.GuardDetailExpressionProvider
-import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature
-import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionPostfix
-import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
-
-/**
- * Defines expression for fsm detail code of an ActorClass
- */
-@FinalFieldsConstructor
-class DefaultDetailExpressionProvider extends GuardDetailExpressionProvider {
-
-	override getInitialFeatures() {
-		// no super call, keep it simple
-		val List<ExpressionFeature> scope = newArrayList
-
-		if(transitionEventData !== null) { 
-			scope += transitionEventData.createExprFeature(ExpressionPostfix.NONE)
-		}
-		if (actorClass!==null) {
-			scope += actorClass.latestOperations.map[createExprFeature]
-			scope += actorClass.allAttributes.map[createExprFeature]
-			actorClass.allInterfaceItems.forEach [
-				switch it {
-					SPP case isEventDriven/* fall through */,
-					Port case isEventDriven && isReplicated: {
-						scope += createExprFeature(ExpressionPostfix.NONE) // additional feature for broadcast 
-						scope += createExprFeature(ExpressionPostfix.BRACKETS)
-					}
-					Port case isReplicated/* fall through  */,
-					SPP:
-						scope += createExprFeature(ExpressionPostfix.BRACKETS)
-					default:
-						scope += createExprFeature(ExpressionPostfix.NONE)
-				}
-			]
-		}
-
-		return scope.filterNull.filter[id !== null].toList
-	}
-
-	override getContextFeatures(ExpressionFeature ctx) {
-		// no super call, keep it simple
-		ctx.assertNotNull
-
-		val List<ExpressionFeature> scope = newArrayList
-		switch obj : ctx.data {
-			Port case obj.multiplicity == 1/* fall through  */,
-			SAP: scope +=
-				obj.protocol.getAllOperations(!obj.conjugated).map[createExprFeature]
-		}
-		switch obj : ctx.data {
-			InterfaceItem: {
-				val pc = obj.protocol
-				switch pc.commType {
-					case EVENT_DRIVEN:
-						scope += pc.getAllMessages(obj.conjugated).map[createExprFeature]
-					case DATA_DRIVEN:
-						if (obj.conjugated)
-							scope += pc.allIncomingMessages.map[createExprFeature]
-						else
-							scope += pc.allIncomingMessages.map[createExprFeature(ExpressionPostfix.NONE)] // data message has no Parenthesis
-					case SYNCHRONOUS: {}
-				}
-
-			// TODO Attributes ?
-			}
-			Attribute case obj.type.type instanceof DataClass: {
-				val dc = obj.type.type as DataClass
-				scope += dc.allAttributes.map[createExprFeature]
-				// not supported yet by code translation:
-				// scope += dc.latestOperations.map[createExprFeature(ExpressionPostfix.PARENTHESES)]
-			}
-		}
-
-		return scope.filterNull.filter[id !== null].toList
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionAssistParser.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionAssistParser.xtend
index 61e7d6439..fc29834e2 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionAssistParser.xtend
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionAssistParser.xtend
@@ -148,6 +148,15 @@ class DetailExpressionAssistParser {
 			false
 		}
 	}
+	
+	def boolean isInitialExpression() {
+		try {
+			document.getChar(invocationOffset - 1) != IDetailExpressionProvider.SEPARATOR && document.get(invocationOffset - 2, 2) != '->'
+		}
+		catch (BadLocationException e) {
+			true
+		}		
+	}
 
 	/**
 	 * non-empty id + not-null suffix
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionProvider.xtend
new file mode 100644
index 000000000..c9d765677
--- /dev/null
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/DetailExpressionProvider.xtend
@@ -0,0 +1,343 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.expressions.detailcode
+
+import com.google.common.base.Strings
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.Sets
+import com.google.inject.Inject
+import java.util.List
+import java.util.Set
+import org.eclipse.core.runtime.Assert
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.etrice.core.fsm.fSM.StateGraphItem
+import org.eclipse.etrice.core.room.ActorClass
+import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.DataType
+import org.eclipse.etrice.core.room.EnumerationType
+import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageData
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.Port
+import org.eclipse.etrice.core.room.PortClass
+import org.eclipse.etrice.core.room.ProtocolClass
+import org.eclipse.etrice.core.room.RefableType
+import org.eclipse.etrice.core.room.RoomClass
+import org.eclipse.etrice.core.room.RoomPackage
+import org.eclipse.etrice.core.room.SAP
+import org.eclipse.etrice.core.room.SPP
+import org.eclipse.etrice.core.room.util.RoomHelpers
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtext.EcoreUtil2
+import org.eclipse.xtext.scoping.IGlobalScopeProvider
+import org.eclipse.xtext.util.SimpleAttributeResolver
+
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.*
+
+import static extension org.eclipse.xtext.EcoreUtil2.getContainerOfType
+
+class DetailExpressionProvider implements IDetailExpressionProvider {
+	
+	@Inject IGlobalScopeProvider globalScopeProvider
+	
+	protected val extension RoomHelpers roomHelpers = new RoomHelpers
+	protected val nameProvider = SimpleAttributeResolver.NAME_RESOLVER
+	
+	/* DetailCode owner */
+	@Accessors EObject owner	
+	
+	/* Role of DetailCode */
+	@Accessors EReference reference	
+	
+	//
+	// Logic for IDetailExpressionProvider.getInitialFeatures()
+	//
+	
+	/* Special transitionData in FSM context */
+	@Accessors
+	MessageData transitionEventData = null
+	
+	/* Cache for expressions in RoomClass context. Can be shared among multiple instance.
+	 * Currently all available DataTypes.
+	 */
+	@Accessors
+	ImmutableList<ExpressionFeature> sharedCache = null
+	
+	def ImmutableList<ExpressionFeature> createAndSetSharedCache() {
+		verifyNotNull(owner)
+		
+		if(sharedCache === null) {
+			val classScope = newArrayList
+			
+			val roomClass = owner.getContainerOfType(RoomClass)
+			if(roomClass !== null) {
+				classTypes(roomClass, classScope)
+			}
+		
+			sharedCache = ImmutableList.copyOf(classScope.filterNull.filter[id !== null])
+		}
+		
+		return sharedCache
+	}
+	
+	override getInitialFeatures() {
+		verifyNotNull(owner)
+		verifyNotNull(owner.eContainer)
+		verifyNotNull(reference)
+		verifyNotNull(globalScopeProvider)
+		
+		val elementScope = newArrayList
+
+		if(transitionEventData !== null) { 
+			elementScope += new ExpressionFeature('transitionData', ExpressionPostfix.NONE) => [
+				data = transitionEventData
+			]
+		}
+		if(owner.isInContainment(Operation)) {
+			elementScope += owner.getContainerOfType(Operation).arguments.map[createExprFeature(ExpressionPostfix.NONE)]
+		}
+		if(!reference.name.contains('userCode')) {
+			val roomClass = owner.getContainerOfType(RoomClass)
+			switch cls: roomClass {
+				ActorClass: {
+					elementScope += cls.latestOperations.map[createExprFeature]
+					elementScope += cls.allAttributes.map[createExprFeature]
+					initialFsmExpression(owner, cls, elementScope)
+				}
+				DataClass: {
+					elementScope += cls.latestOperations.map[createExprFeature]
+					elementScope += cls.allAttributes.map[createExprFeature]
+				}
+				case owner.isInContainment(PortClass): {
+					val portClass = owner.getContainerOfType(PortClass)
+					// TODO inheritance
+					elementScope += portClass.operations.map[createExprFeature]
+					elementScope += portClass.attributes.map[createExprFeature]
+				}
+			}	
+		}	
+		
+		val typesScope = {
+			switch reference {
+				case CP_BRANCH_TRANSITION__CONDITION,
+				case GUARDED_TRANSITION__GUARD,
+				case GUARD__GUARD: {	
+					// enums only			
+					createAndSetSharedCache.filter[data instanceof EnumerationType]
+				}
+				default: createAndSetSharedCache
+			}
+		}
+		
+		return (elementScope.filterNull.filter[id !== null] + typesScope).toList
+	}
+	
+	/**
+	 *  TODO align with generator
+	 */
+	protected def void classTypes(RoomClass cls, List<ExpressionFeature> scope) {
+		val types = <DataType>newHashSet
+		
+		// imported types
+		types += globalScopeProvider.getScope(cls.eResource, RoomPackage.Literals.REFABLE_TYPE__TYPE, null)
+					.allElements.map[EObjectOrProxy].filter(DataType)
+		// local types
+		types += EcoreUtil.getRootContainer(cls).eContents.filter(DataType)
+		
+		// indirectly referenced types	
+		types += {
+			// everything that contains RefableType
+			val refableContainers = switch cls {
+				ActorClass:
+					cls.allInterfaceItems.map[protocol].filterNull.toHashSet.map[classHierarchy].flatten + cls.attributes + cls.operations
+				ProtocolClass:
+					#[cls] + cls.classHierarchy
+				DataClass:
+					#[cls] + cls.classHierarchy
+				default:
+					emptyList
+			}
+			// get all data types
+			refableContainers.map[EcoreUtil2.eAllOfType(it, RefableType)].flatten.map[type]
+		}
+		
+		// nested + class hierarchy of DataClasses
+		var toResolve = types.filter(DataClass).toList
+		while(!toResolve.empty) {
+			val newTypes = toResolve.map[EcoreUtil2.eAllOfType(it, RefableType)].flatten.map[type].toHashSet
+			toResolve = Sets.difference(newTypes, types).filter(DataClass).map[base].filterNull.map[classHierarchy].flatten.toList
+			types += newTypes
+		}
+		
+		scope += types.map[createExprFeature(it, ExpressionPostfix.NONE)]
+	}
+	
+	protected def void initialFsmExpression(EObject model, ActorClass ac, List<ExpressionFeature> scope) {		
+		switch reference {
+			case CP_BRANCH_TRANSITION__CONDITION,
+			case GUARDED_TRANSITION__GUARD: {
+				scope += ac.allInterfaceItems.filter[isEventDriven || !isConjugated].map[
+					switch it {
+						Port case isReplicated: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.BRACKETS)
+						default: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.NONE)
+				}]
+			}
+			case model.isInContainment(StateGraphItem): {
+				ac.allInterfaceItems.forEach [
+					switch it {
+						SPP case isEventDriven/* fall through */,
+						Port case isEventDriven && isReplicated: {
+							scope += createExprFeature(ExpressionPostfix.NONE) // additional feature for broadcast 
+							scope += createExprFeature(ExpressionPostfix.BRACKETS)
+						}
+						Port case isReplicated/* fall through  */,
+						SPP:
+							scope += createExprFeature(ExpressionPostfix.BRACKETS)
+						default:
+							scope += createExprFeature(ExpressionPostfix.NONE)
+					}
+				]	
+			}
+		}
+	}
+	
+	//
+	// Logic for IDetailExpressionProvider.getContextFeatures()
+	//
+	
+	override getContextFeatures(ExpressionFeature ctx) {
+		verifyNotNull(ctx)
+		verifyNotNull(owner)
+		verifyNotNull(reference)
+		
+		val List<ExpressionFeature> scope = newArrayList
+		
+		switch obj : ctx.data {
+			Port case obj.multiplicity == 1/* fall through  */,
+			SAP: scope += obj.protocol.getAllOperations(!obj.conjugated).map[createExprFeature]
+		}
+		switch obj : ctx.data {
+			InterfaceItem:
+				contextFsmMessages(obj, ctx, scope)		
+			Attribute case obj.type?.type instanceof DataClass: {
+				val dc = obj.type.type as DataClass
+				scope += dc.allAttributes.map[createExprFeature]
+				scope += dc.latestOperations.map[createExprFeature]
+			}
+			MessageData case obj.refType?.type instanceof DataClass: {
+				val dc = obj.refType.type as DataClass
+				scope += dc.allAttributes.map[createExprFeature]
+				scope += dc.latestOperations.map[createExprFeature]
+			}
+			EnumerationType: {
+				// from descriptions, have to be resolved
+				var enumType = obj
+				if(obj.eIsProxy) {
+					val resolved = EcoreUtil.resolve(obj, owner)
+					if(resolved instanceof EnumerationType)
+						enumType = resolved
+				}
+				scope += enumType.literals.map[createExprFeature(it, ExpressionPostfix.NONE)]	
+			}
+		}
+
+		return scope.filterNull.filter[id !== null].toList
+	}
+	
+	protected def void contextFsmMessages(InterfaceItem ifItem, ExpressionFeature ctx, List<ExpressionFeature> scope) {				
+		switch reference {
+			case CP_BRANCH_TRANSITION__CONDITION,
+			case GUARDED_TRANSITION__GUARD,
+			case GUARD__GUARD: {
+				val pc = ifItem.protocol
+				switch pc?.commType {
+					case DATA_DRIVEN:
+						if (!ifItem.conjugated) scope += pc.allIncomingMessages.map[createExprFeature]
+					case EVENT_DRIVEN: { /* no async message calls */}
+					case SYNCHRONOUS: {}
+				}
+			}
+			case owner.isInContainment(StateGraphItem): {
+				val pc = ifItem.protocol
+				switch pc?.commType {
+					case EVENT_DRIVEN:
+						scope += pc.getAllMessages(ifItem.conjugated).map[createExprFeature]
+					case DATA_DRIVEN:
+						if (ifItem.conjugated)
+							scope += pc.allIncomingMessages.map[createExprFeature]
+						else
+							scope += pc.allIncomingMessages.map[createExprFeature(ExpressionPostfix.NONE)] // data message has no Parenthesis
+					case SYNCHRONOUS: {}
+				}				
+			}
+		}
+	}
+	
+	//
+	// extensions
+	//
+	
+	def ExpressionFeature createExprFeature(Operation it){
+		// assuming all operations have parenthesis
+		createExprFeature(IDetailExpressionProvider.ExpressionPostfix.PARENTHESES)
+	}
+	
+	def ExpressionFeature createExprFeature(Message it){
+		// assuming all message have parenthesis
+		createExprFeature(IDetailExpressionProvider.ExpressionPostfix.PARENTHESES)
+	}
+	
+	def ExpressionFeature createExprFeature(Attribute it){
+		// assuming all attributes have brackets or not depending on size
+		switch (size) {
+			case size > 1: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.BRACKETS)
+			default: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.NONE)
+		}
+	}
+
+	def protected createExprFeature(EObject eObj, ExpressionPostfix postfix) {
+		val feature = new ExpressionFeature(nameProvider.apply(eObj), postfix)
+		feature.data = eObj
+
+		return feature
+	}
+
+	def protected assertNotNull(ExpressionFeature feature) {
+		Assert.isTrue(!Strings.isNullOrEmpty(feature.id))
+		Assert.isNotNull(feature.postfix)
+		Assert.isNotNull(feature.data)
+	}
+	
+	private def isInContainment(EObject it, Class<? extends EObject> clazz) {
+		getContainerOfType(clazz) !== null
+	}
+	
+	private def static <T> Set<T> toHashSet(Iterable<T> iterable) {
+		if (iterable instanceof Set<?>) {
+			return iterable as Set<T>
+		}
+		return Sets.newHashSet(iterable);
+	}
+	
+	private def <T> verifyNotNull(T ref) {
+		if(ref === null)
+			throw new NullPointerException
+		
+		return ref
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/GuardDetailExpressionProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/GuardDetailExpressionProvider.xtend
deleted file mode 100644
index b9a21d899..000000000
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/GuardDetailExpressionProvider.xtend
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Juergen Haug (initial contribution)
- * 
- *******************************************************************************/
-package org.eclipse.etrice.expressions.detailcode
-
-import com.google.common.base.Strings
-import java.util.List
-import org.eclipse.core.runtime.Assert
-import org.eclipse.emf.ecore.EObject
-import org.eclipse.etrice.core.room.ActorClass
-import org.eclipse.etrice.core.room.Attribute
-import org.eclipse.etrice.core.room.DataClass
-import org.eclipse.etrice.core.room.InterfaceItem
-import org.eclipse.etrice.core.room.Message
-import org.eclipse.etrice.core.room.Operation
-import org.eclipse.etrice.core.room.Port
-import org.eclipse.etrice.core.room.SAP
-import org.eclipse.etrice.core.room.VarDecl
-import org.eclipse.etrice.core.room.util.RoomHelpers
-import org.eclipse.xtend.lib.annotations.AccessorType
-import org.eclipse.xtend.lib.annotations.Accessors
-import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
-import org.eclipse.xtext.util.SimpleAttributeResolver
-
-import static extension org.eclipse.xtend.lib.annotations.AccessorType.*
-
-/**
- * Defines expression for fsm guards of an ActorClass
- * <ul>
- * <li>attributes and operations of ActorClass</li>
- * <li>data-driven incoming messages</li>
- * </ul>
- */
- @FinalFieldsConstructor
-class GuardDetailExpressionProvider implements IDetailExpressionProvider {
-
-	// ctor
-	protected val ActorClass actorClass
-	protected val extension RoomHelpers roomHelpers = new RoomHelpers
-	protected val nameProvider = SimpleAttributeResolver.NAME_RESOLVER
-	
-	// optional
-	@Accessors(AccessorType.PUBLIC_SETTER) protected VarDecl transitionEventData
-
-	override getInitialFeatures() {
-		val List<ExpressionFeature> scope = newArrayList
-
-		if(transitionEventData !== null) { 
-			scope += transitionEventData.createExprFeature(IDetailExpressionProvider.ExpressionPostfix.NONE)
-		}
-		if(actorClass !== null) {
-			scope += actorClass.allInterfaceItems.filter[isEventDriven || !isConjugated].map[
-				switch it {
-					Port case isReplicated: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.BRACKETS)
-					default: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.NONE)
-			}]
-			scope += actorClass.latestOperations.map[createExprFeature]
-			scope += actorClass.allAttributes.map[createExprFeature]
-		}
-
-		return scope.filterNull.filter[id !== null].toList
-	}
-
-	override getContextFeatures(ExpressionFeature ctx) {
-		ctx.assertNotNull
-
-		val List<ExpressionFeature> scope = newArrayList
-		switch obj : ctx.data {
-			Port case obj.multiplicity == 1/* fall through  */,
-			SAP: scope +=
-				obj.protocol.getAllOperations(!obj.conjugated).map[createExprFeature]
-		}
-		switch obj : ctx.data {
-			InterfaceItem: {
-				val pc = obj.protocol
-				switch pc.commType {
-					case DATA_DRIVEN:
-						if (!obj.conjugated) scope += pc.allIncomingMessages.map[createExprFeature]
-					case EVENT_DRIVEN: { /* no async message calls */}
-					case SYNCHRONOUS: {}
-				}
-			}
-			Attribute case obj.type.type instanceof DataClass: {
-				val dc = obj.type.type as DataClass
-				scope += dc.allAttributes.map[createExprFeature]
-				scope += dc.latestOperations.map[createExprFeature]
-			}
-		}
-
-		return scope.filterNull.filter[id !== null].toList
-	}
-	
-	def ExpressionFeature createExprFeature(Operation it){
-		// assuming all operations have parenthesis
-		createExprFeature(IDetailExpressionProvider.ExpressionPostfix.PARENTHESES)
-	}
-	
-	def ExpressionFeature createExprFeature(Message it){
-		// assuming all message have parenthesis
-		createExprFeature(IDetailExpressionProvider.ExpressionPostfix.PARENTHESES)
-	}
-	
-	def ExpressionFeature createExprFeature(Attribute it){
-		// assuming all attributes have brackets or not depending on size
-		switch (size) {
-			case size > 1: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.BRACKETS)
-			default: createExprFeature(IDetailExpressionProvider.ExpressionPostfix.NONE)
-		}
-	}
-
-	def protected createExprFeature(EObject eObj, ExpressionPostfix postfix) {
-		val feature = new ExpressionFeature(nameProvider.apply(eObj), postfix)
-		feature.data = eObj
-
-		return feature
-	}
-
-	def protected assertNotNull(ExpressionFeature feature) {
-		Assert.isTrue(!Strings.isNullOrEmpty(feature.id))
-		Assert.isNotNull(feature.postfix)
-		Assert.isNotNull(feature.data)
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/IDetailExpressionProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/IDetailExpressionProvider.xtend
index d2f139d1f..b08b098e5 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/IDetailExpressionProvider.xtend
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/IDetailExpressionProvider.xtend
@@ -15,6 +15,7 @@ package org.eclipse.etrice.expressions.detailcode
 import com.google.common.collect.ImmutableList
 import java.util.List
 import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.emf.ecore.EObject
 
 /**
  * Defines abstract syntax of detail expressions = <i>ExpressionFeature ('.' ExpressionFeature)* </i>
@@ -44,6 +45,14 @@ interface IDetailExpressionProvider {
 		val String id 					// name
 		val ExpressionPostfix postfix	// follows name
 		Object data						// business object
+		
+		override toString() {
+			id + switch postfix {
+				case PARENTHESES: '()'
+				case BRACKETS: '[]'
+				default: ''
+			} + ' - ' + if(data instanceof EObject) data.eClass.name else data
+		}
 	}
 
 	enum ExpressionPostfix {
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/RuntimeDetailExpressionProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/RuntimeDetailExpressionProvider.xtend
deleted file mode 100644
index 101e1ad8e..000000000
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/detailcode/RuntimeDetailExpressionProvider.xtend
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.eclipse.etrice.expressions.detailcode
-
-import org.eclipse.emf.ecore.EObject
-import org.eclipse.etrice.core.room.InterfaceItem
-import org.eclipse.etrice.core.room.Port
-import org.eclipse.etrice.core.room.SPP
-import org.eclipse.xtend.lib.annotations.Accessors
-import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
-
-/**
- * Defines expression that does not have an model representation. Extends {@link DefaultDetailExpressionProvider} 
- */
-@FinalFieldsConstructor
-class RuntimeDetailExpressionProvider extends DefaultDetailExpressionProvider {
-
-	public static val RT_METHOD_GET_REPLICATION = "getReplication"
-
-	@Accessors
-	static class RuntimeMethodExpressionData {
-		//val String methodName
-		//EObject eObj
-	}
-
-	override getContextFeatures(ExpressionFeature ctx) {
-		val scope = super.getContextFeatures(ctx)
-
-		switch obj : ctx.data {
-			InterfaceItem: {
-				if (ctx.postfix == ExpressionPostfix.NONE) {
-					switch obj {
-						Port case obj.replicated/* fall through */,
-						SPP: {
-							// not supported yet by code translation
-							//scope += createRtMethodExprFeature(RT_METHOD_GET_REPLICATION, obj)
-						}
-					}
-				}
-			}
-		}
-
-		return scope.filterNull.filter[id !== null].toList
-	}
-
-	protected def createRtMethodExprFeature(String methodName, EObject eObj) {
-		val feature = new ExpressionFeature(methodName, ExpressionPostfix.PARENTHESES)
-		feature.data = new RuntimeMethodExpressionData()
-
-		return feature
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/DetailExpressionProposalConfig.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/DetailExpressionProposalConfig.xtend
index 8ef1de49c..4bd74a596 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/DetailExpressionProposalConfig.xtend
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/DetailExpressionProposalConfig.xtend
@@ -19,6 +19,7 @@ import org.eclipse.emf.ecore.EObject
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.InterfaceItem
 import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageData
 import org.eclipse.etrice.core.room.Operation
 import org.eclipse.etrice.core.room.Port
 import org.eclipse.etrice.core.room.SPP
@@ -26,8 +27,7 @@ import org.eclipse.etrice.core.room.VarDecl
 import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionPostfix
-import org.eclipse.etrice.expressions.detailcode.RuntimeDetailExpressionProvider
-import org.eclipse.etrice.expressions.detailcode.RuntimeDetailExpressionProvider.RuntimeMethodExpressionData
+import org.eclipse.etrice.generator.generic.ILanguageExtension
 import org.eclipse.jface.viewers.ILabelProvider
 import org.eclipse.swt.graphics.Image
 import org.eclipse.swt.graphics.Point
@@ -35,7 +35,7 @@ import org.eclipse.swt.graphics.Point
 @Singleton
 class DetailExpressionProposalConfig{
 
-	static val String IMAGE_RT_METHOD = "icons/rt_method.png"
+//	static val String IMAGE_RT_METHOD = "icons/rt_method.png"
 
 	@Inject
 	protected ILabelProvider labelProvider
@@ -58,7 +58,7 @@ class DetailExpressionProposalConfig{
 			Operation:
 				data.arguments.map[name].join(', ')
 			Message case data.data !== null:
-				data.data.name
+				ILanguageExtension.GENERIC_DATA_NAME
 			Attribute, // fall through
 			InterfaceItem:
 				'0'
@@ -78,7 +78,7 @@ class DetailExpressionProposalConfig{
 
 		var postfix = getPostfixReplacement(feature)
 		var point = postfix.value
-		if (point != null)
+		if (point !== null)
 			point.x += feature.id.length
 
 		return feature.id + postfix.key -> point
@@ -98,20 +98,23 @@ class DetailExpressionProposalConfig{
 		var classInfo = if(data instanceof EObject) data.eClass.name else ""
 		switch data {
 			Attribute:
-				typedInfo = data.type.type.name
+				typedInfo = data?.type?.type?.name
 			InterfaceItem:
-				typedInfo = roomHelpers.getProtocol(data).name
-			RuntimeMethodExpressionData case feature.id == RuntimeDetailExpressionProvider.RT_METHOD_GET_REPLICATION:
-				typedInfo = 'int'
+				typedInfo = roomHelpers.getProtocol(data)?.name
+//			RuntimeMethodExpressionData case feature.id == RuntimeDetailExpressionProvider.RT_METHOD_GET_REPLICATION:
+//				typedInfo = 'int'
 			VarDecl: {
-				typedInfo = data.refType.type.name
+				typedInfo = data?.refType?.type?.name
 				classInfo = ""
 			}
+			MessageData: {
+				typedInfo = data?.refType?.type?.name
+			}
 			default: {
 				val label = labelProvider.getText(data)
 
 				// if label starts with completion then label might be better
-				if(!Strings.commonPrefix(label, completionInfo).empty) completionInfo = label
+				if(label !== null && !Strings.commonPrefix(label, completionInfo).empty) completionInfo = label
 			}
 		}
 
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/RoomExpressionProposalProvider.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/RoomExpressionProposalProvider.xtend
index 4fa60b46d..ae7d1ae85 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/RoomExpressionProposalProvider.xtend
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/contentassist/RoomExpressionProposalProvider.xtend
@@ -41,12 +41,15 @@ class RoomExpressionProposalProvider {
 		// parser to use
 		val parser = new DetailExpressionAssistParser(new Document(text), offset, exprProvider)
 		// get features that follow last completed feature			
-		val availableFeatures = newArrayList => [
+		val availableFeatures = newArrayList => [ features |
 			if(parser.isContextExpression) {
 				val contextFeature = parser?.resolveLatestCompleted
-				it += if(contextFeature !== null) exprProvider.getContextFeatures(contextFeature) else exprProvider.initialFeatures
-			} else {
-				it += exprProvider.initialFeatures
+				if(contextFeature !== null)				
+					features += exprProvider.getContextFeatures(contextFeature)
+				else if(parser.isInitialExpression)
+					features += exprProvider.initialFeatures
+			} else if(parser.isInitialExpression) {
+				features += exprProvider.initialFeatures
 			}	
 		]
 		// filter by incomplete text prefix
diff --git a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/highlight/AbstractHighlightStyles.xtend b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/highlight/AbstractHighlightStyles.xtend
index f6a2ff065..25e4e33b1 100644
--- a/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/highlight/AbstractHighlightStyles.xtend
+++ b/plugins/org.eclipse.etrice.expressions.ui/src/org/eclipse/etrice/expressions/ui/highlight/AbstractHighlightStyles.xtend
@@ -12,13 +12,18 @@
 
 package org.eclipse.etrice.expressions.ui.highlight
 
-import org.eclipse.emf.ecore.EObject
 import org.eclipse.etrice.core.room.Attribute
+import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.EnumLiteral
+import org.eclipse.etrice.core.room.EnumerationType
 import org.eclipse.etrice.core.room.InterfaceItem
+import org.eclipse.etrice.core.room.MessageData
 import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.VarDecl
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider.ExpressionFeature
-import org.eclipse.etrice.expressions.detailcode.RuntimeDetailExpressionProvider.RuntimeMethodExpressionData
 import org.eclipse.swt.graphics.RGB
+import org.eclipse.etrice.core.room.PrimitiveType
+import org.eclipse.etrice.core.room.ExternalType
 
 /** Enables re-usability of scanner for xtext and jface editor */
 abstract class AbstractHighlightStyles {
@@ -34,6 +39,10 @@ abstract class AbstractHighlightStyles {
 	public static val OPERATION_RGB = new RGB(204, 153, 0)
 	public static val ATTRIBUTE_RGB = new RGB(105, 185, 0)
 	public static val INTERFACE_ITEM_RGB = new RGB(200, 100, 0)
+	public static val ENUM_RGB = new RGB(90, 95, 180)
+	public static val DATA_CLASS_RGB = new RGB(0, 125, 0)
+	public static val PRIMITIVE_TYPE_RGB = new RGB(60, 135, 130)
+	public static val EXTERNAL_TYPE_RGB = new RGB(140, 125, 0)
 	
 	def Object getDefault()
 	def Object getTargetKeyword()
@@ -44,6 +53,10 @@ abstract class AbstractHighlightStyles {
 	def Object getOperation()
 	def Object getAttribute()
 	def Object getInterfaceItem()
+	def Object getEnum()
+	def Object getDataClass()
+	def Object getPrimitiveType()
+	def Object getExternalType()
 	
 	def Object getStyle(ExpressionFeature feature) {
 		// xtext uses ID
@@ -54,10 +67,20 @@ abstract class AbstractHighlightStyles {
 				attribute
 			Operation:
 				operation
-			EObject:
-				specialFeature // unknown model object == special
-			RuntimeMethodExpressionData:
-				operation
+			EnumerationType,
+			EnumLiteral:
+				enum
+			DataClass:
+				dataClass
+			PrimitiveType:
+				primitiveType
+			ExternalType:
+				externalType
+			MessageData,
+			VarDecl:
+				specialFeature
+//			RuntimeMethodExpressionData:
+//				operation
 		}
 	}
 	
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ActorClassGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ActorClassGen.xtend
index 38149764e..79a399520 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ActorClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ActorClassGen.xtend
@@ -18,7 +18,8 @@ import com.google.inject.Singleton
 import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType
 import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.CommunicationType
 import org.eclipse.etrice.core.room.Operation
 import org.eclipse.etrice.core.room.ProtocolClass
@@ -75,7 +76,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		val async = ac.commType==ComponentCommunicationType::ASYNCHRONOUS
 		val hasConstData = !(eventPorts.empty && recvPorts.empty && ac.allSAPs.empty && ac.allServiceImplementations.empty)
 							|| Main::settings.generateMSCInstrumentation
-		val hasVarData = !(sendPorts.empty && ac.allAttributes.empty && xpac.stateMachine.empty && !hasConstData)
+		val isEmptyStateGraph = FsmGenExtensions.isEmpty(xpac.graphContainer.graph)
+		val hasVarData = !(sendPorts.empty && ac.allAttributes.empty && isEmptyStateGraph && !hasConstData)
 
 	'''
 		/**
@@ -141,7 +143,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 			/* this actor class has no ports and thus no constant data */
 		«ENDIF»
 
-		«IF !xpac.stateMachine.empty»
+		«IF !isEmptyStateGraph»
 
 			«xpac.genHeaderConstants»
 		«ENDIF»
@@ -162,7 +164,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 
 				«ac.allAttributes.attributes»
 
-				«IF !xpac.stateMachine.empty»
+				«IF !isEmptyStateGraph»
 
 					«xpac.genDataMembers»
 				«ENDIF»
@@ -202,7 +204,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 		val replEventPorts = eventPorts.filter[multiplicity!=1]
 		val sendPorts = ac.allEndPorts.filter(p|(p.protocol as ProtocolClass).commType==CommunicationType::DATA_DRIVEN &&  p.conjugated && p.multiplicity==1)
 		val recvPorts = ac.allEndPorts.filter(p|(p.protocol as ProtocolClass).commType==CommunicationType::DATA_DRIVEN && !p.conjugated && p.multiplicity==1)
-		val portsWithOperations = ac.allInterfaceItems.filter(p|p.portClass!=null && p.portClass.operations.size>0)
+		val portsWithOperations = ac.allInterfaceItems.filter(p|p.portClass!==null && p.portClass.operations.size>0)
 		val filename = (ac.eContainer as RoomModel).name.replaceAll("\\.","_")+"_"+ac.name+"_Utils"
 
 	'''
@@ -224,8 +226,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		/* simple event ports */
 		«FOR ep : eventPorts.filter[multiplicity==1]»
 			«FOR msg : ep.outgoing»
-				«val data1 = if (msg.data!=null) "data" else ""»
-				«val data2 = if (msg.data!=null) ", data" else ""»
+				«val data1 = if (msg.data!==null) "data" else ""»
+				«val data2 = if (msg.data!==null) ", data" else ""»
 				#define «ep.name»_«msg.name»(«data1») «ep.portClassName»_«msg.name»(&self->constData->«ep.name»«data2»)
 			«ENDFOR»
 		«ENDFOR»
@@ -240,8 +242,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		/* data send ports */
 		«FOR ep : sendPorts»
 			«FOR msg : ep.outgoing»
-				«val data1 = if (msg.data!=null) "data" else ""»
-				«val data2 = if (msg.data!=null) ", data" else ""»
+				«val data1 = if (msg.data!==null) "data" else ""»
+				«val data2 = if (msg.data!==null) ", data" else ""»
 				#define «ep.name»_«msg.name»(«data1») «ep.portClassName»_«msg.name»_set(&self->«ep.name»«data2»)
 			«ENDFOR»
 		«ENDFOR»
@@ -249,8 +251,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		/* saps */
 		«FOR sap: ac.allSAPs»
 			«FOR msg : sap.outgoing»
-				«val data1 = if (msg.data!=null) "data" else ""»
-				«val data2 = if (msg.data!=null) ", data" else ""»
+				«val data1 = if (msg.data!==null) "data" else ""»
+				«val data2 = if (msg.data!==null) ", data" else ""»
 				#define «sap.name»_«msg.name»(«data1») «sap.portClassName»_«msg.name»(&self->constData->«sap.name»«data2»)
 			«ENDFOR»
 		«ENDFOR»
@@ -261,8 +263,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		«ENDIF»
 		«FOR ep : replEventPorts»
 			«FOR msg : ep.outgoing»
-				«val data1 = if (msg.data!=null) "data" else ""»
-				«val data2 = if (msg.data!=null) ", data" else ""»
+				«val data1 = if (msg.data!==null) "data" else ""»
+				«val data2 = if (msg.data!==null) ", data" else ""»
 				#define «ep.name»_«msg.name»_broadcast(«data1») «ep.portClassName»_«msg.name»_broadcast(&self->constData->«ep.name»«data2»)
 				#define «ep.name»_«msg.name»(idx«data2») «ep.portClassName»_«msg.name»(&self->constData->«ep.name», idx«data2»)
 			«ENDFOR»
@@ -271,8 +273,8 @@ class ActorClassGen extends GenericActorClassGenerator {
 		/* services */
 		«FOR svc : ac.allServiceImplementations»
 			«FOR msg : svc.spp.outgoing»
-				«val data1 = if (msg.data!=null) "data" else ""»
-				«val data2 = if (msg.data!=null) ", data" else ""»
+				«val data1 = if (msg.data!==null) "data" else ""»
+				«val data2 = if (msg.data!==null) ", data" else ""»
 				#define «svc.spp.name»_«msg.name»_broadcast(«data1») «svc.spp.portClassName»_«msg.name»_broadcast(&self->constData->«svc.spp.name»«data2»)
 				#define «svc.spp.name»_«msg.name»(idx«data2») «svc.spp.portClassName»_«msg.name»(&self->constData->«svc.spp.name», idx«data2»)
 			«ENDFOR»
@@ -312,6 +314,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 		val eventDriven = ac.commType==ComponentCommunicationType::EVENT_DRIVEN
 		val dataDriven = ac.commType==ComponentCommunicationType::DATA_DRIVEN
 		val handleEvents = async || eventDriven
+		val isEmptyStateGraph = FsmGenExtensions.isEmpty(xpac.graphContainer.graph)
 
 	'''
 		/**
@@ -340,13 +343,13 @@ class ActorClassGen extends GenericActorClassGenerator {
 		/* interface item IDs */
 		«xpac.genInterfaceItemConstants»
 
-		«IF !xpac.stateMachine.empty»
-			«xpac.genStateMachine()»
+		«IF !isEmptyStateGraph»
+			«xpac.graphContainer.genStateMachine»
 		«ENDIF»
 
 		void «ac.name»_init(«ac.name»* self){
 			ET_MSC_LOGGER_SYNC_ENTRY("«ac.name»", "init")
-			«IF !xpac.stateMachine.empty»
+			«IF !isEmptyStateGraph»
 				«xpac.genInitialization»
 			«ENDIF»
 			ET_MSC_LOGGER_SYNC_EXIT
@@ -355,7 +358,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 
 		void «ac.name»_receiveMessage(void* self, const void* ifitem, const etMessage* msg){
 			ET_MSC_LOGGER_SYNC_ENTRY("«ac.name»", "_receiveMessage")
-			«IF !xpac.stateMachine.empty»
+			«IF !isEmptyStateGraph»
 				«IF handleEvents»
 					«langExt.operationScope(ac.name, false)»receiveEvent(self, (etPort*)ifitem, msg->evtID, (void*)(((char*)msg)+MEM_CEIL(sizeof(etMessage))));
 				«ELSE»
@@ -369,7 +372,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 		«IF dataDriven || async»
 			void «ac.name»_execute(«ac.name»* self) {
 				ET_MSC_LOGGER_SYNC_ENTRY("«ac.name»", "_execute")
-				«IF !xpac.stateMachine.empty»
+				«IF !isEmptyStateGraph»
 
 					«IF handleEvents»
 						«langExt.operationScope(ac.name, false)»receiveEvent(self, NULL, 0, NULL);
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CExtensions.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CExtensions.xtend
index 4639c8f7e..f5770af10 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CExtensions.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CExtensions.xtend
@@ -21,26 +21,25 @@ package org.eclipse.etrice.generator.c.gen
 import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.common.base.LiteralType
 import org.eclipse.etrice.core.etphys.eTPhys.NodeRef
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.DataClass
 import org.eclipse.etrice.core.room.DataType
+import org.eclipse.etrice.core.room.EnumLiteral
+import org.eclipse.etrice.core.room.EnumerationType
 import org.eclipse.etrice.core.room.ExternalType
-import org.eclipse.etrice.core.common.base.LiteralType
 import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageData
 import org.eclipse.etrice.core.room.PrimitiveType
 import org.eclipse.etrice.core.room.RoomClass
 import org.eclipse.etrice.core.room.RoomModel
-import org.eclipse.etrice.core.room.VarDecl
+import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.generic.ILanguageExtension
 import org.eclipse.xtext.util.Pair
-import org.eclipse.etrice.core.room.EnumerationType
-
-import org.eclipse.etrice.core.room.util.RoomHelpers
-import org.eclipse.etrice.core.room.EnumLiteral
-import org.eclipse.emf.ecore.EObject
 
 @Singleton
 class CExtensions implements ILanguageExtension {
@@ -50,7 +49,7 @@ class CExtensions implements ILanguageExtension {
 
 	override String getTypedDataDefinition(EObject msg) {
 	    if (msg instanceof Message) {
-    		generateArglistAndTypedData((msg as Message).data).get(1)
+    		generateArglistAndTypedData((msg as Message).data).get(TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal)
 	    }
 	    else {
 	        ""
@@ -237,7 +236,7 @@ class CExtensions implements ILanguageExtension {
 			EnumerationType:
 				getDefaultValue(dt)
 			ExternalType:{
-				if (dt.defaultValueLiteral != null )
+				if (dt.defaultValueLiteral !== null )
 					return dt.getDefaultValueLiteral
 				diagnostician.error("external type "+dt.name + "has no default initialization", dt.eContainer, dt.eContainingFeature)
 				""
@@ -283,7 +282,7 @@ class CExtensions implements ILanguageExtension {
 
 	def initializationWithDefaultValues(Attribute att) {
 		val dv = att.defaultValueLiteral
-		if (dv!=null) {
+		if (dv!==null) {
 			if (dv.startsWith("{"))
 				dv
 			else
@@ -297,11 +296,12 @@ class CExtensions implements ILanguageExtension {
 	}
 
 	override generateArglistAndTypedData(EObject d) {
-		if (d==null || !(d instanceof VarDecl))
+		// TODO 529445: d will be a RefableType, not MessageData
+		if (d===null || !(d instanceof MessageData))
 			return newArrayList("", "", "")
 
-		val data = d as VarDecl
-		if (data==null)
+		val data = d as MessageData
+		if (data===null)
 			return newArrayList("", "", "")
 
 		var typeName = if (data.getRefType().getType() instanceof PrimitiveType)
@@ -315,7 +315,7 @@ class CExtensions implements ILanguageExtension {
 
 		var castTypeName = if (data.getRefType().getType() instanceof PrimitiveType) {
 			val ct = (data.getRefType().getType() as PrimitiveType).getCastName()
-			if (ct!=null && !ct.isEmpty())
+			if (ct!==null && !ct.isEmpty())
 				ct
 			else
 				typeName
@@ -341,10 +341,9 @@ class CExtensions implements ILanguageExtension {
 			}
 		}
 
-		val typedData = typeName+" "+data.getName() + " = "+deRef+"(("+castTypeName+") generic_data__et);\n"
-
-		val dataArg = ", "+data.getName()
-		val typedArgList = ", "+typeName+" "+data.getName()
+		val dataArg = ", "+GENERIC_DATA_NAME
+		val typedData = typeName+" "+GENERIC_DATA_NAME + " = "+deRef+"(("+castTypeName+") generic_data__et);\n"
+		val typedArgList = ", "+typeName+" "+GENERIC_DATA_NAME
 
 		return newArrayList(dataArg, typedData, typedArgList);
 	}
@@ -358,7 +357,7 @@ class CExtensions implements ILanguageExtension {
 	}
 
 	override getTargetType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
+		if (type.getPrimitiveType()!==null)
 			type.getPrimitiveType().getTargetName()
 		else
 			type.getName()
@@ -368,14 +367,14 @@ class CExtensions implements ILanguageExtension {
 		val type = literal.eContainer() as EnumerationType
 		val cast = type.targetType
 
-		if (type.primitiveType==null)
+		if (type.primitiveType===null)
 			Long.toString(literal.getLiteralValue())
 		else
 			"(("+cast+")"+Long.toString(literal.getLiteralValue())+")"
 	}
 
 	override getCastType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
+		if (type.getPrimitiveType()!==null)
 			type.getPrimitiveType().getCastName()
 		else
 			type.getName()
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CTranslationProvider.java b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CTranslationProvider.java
index 33f6e1a6e..fc6ed1edb 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/CTranslationProvider.java
@@ -12,13 +12,13 @@
 
 package org.eclipse.etrice.generator.c.gen;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.room.Attribute;
-import org.eclipse.etrice.core.room.CommunicationType;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.DetailCode;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.CommunicationType;
 import org.eclipse.etrice.core.room.EnumLiteral;
 import org.eclipse.etrice.core.room.EnumerationType;
 import org.eclipse.etrice.core.room.InterfaceItem;
@@ -51,7 +51,7 @@ public class CTranslationProvider extends DefaultTranslationProvider {
 	}
 
 	@Override
-	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, ArrayList<String> args, String index, String orig) {
+	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, List<String> args, String index, String orig) {
 		if (!(abstractMsg instanceof Message))
 			return orig;
 		
@@ -110,11 +110,11 @@ public class CTranslationProvider extends DefaultTranslationProvider {
 	}
 
 	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.generator.base.DefaultTranslationProvider#getInterfaceItemOperationText(org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem, org.eclipse.etrice.core.room.PortOperation, java.util.ArrayList, java.lang.String)
+	 * @see org.eclipse.etrice.generator.base.DefaultTranslationProvider#getInterfaceItemOperationText(org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem, org.eclipse.etrice.core.room.PortOperation, java.util.List, java.lang.String)
 	 */
 	@Override
 	public String getInterfaceItemOperationText(AbstractInterfaceItem item,
-			PortOperation op, ArrayList<String> args, String orig) {
+			PortOperation op, List<String> args, String orig) {
 		
 		StringBuilder argtext = new StringBuilder();
 		for (String arg : args) {
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/DataClassGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/DataClassGen.xtend
index be02b34b4..7024481e3 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/DataClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/DataClassGen.xtend
@@ -15,17 +15,16 @@ package org.eclipse.etrice.generator.c.gen
 
 import com.google.inject.Inject
 import com.google.inject.Singleton
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
 import org.eclipse.etrice.core.genmodel.etricegen.Root
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.Operation
+import org.eclipse.etrice.core.room.RoomModel
+import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo
 import org.eclipse.etrice.generator.generic.ProcedureHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 
-import org.eclipse.etrice.core.room.util.RoomHelpers
-import org.eclipse.etrice.core.room.RoomModel
-import org.eclipse.etrice.core.room.Operation
-
 @Singleton
 class DataClassGen {
 
@@ -81,7 +80,7 @@ class DataClassGen {
 		} «dc.name»;
 		
 		«FOR a:dc.allAttributes»
-			«IF a.defaultValueLiteral!=null»
+			«IF a.defaultValueLiteral!==null»
 				«logger.logInfo(dc.name+" "+a.name+": Attribute initialization not supported in C")»
 			«ENDIF»
 		«ENDFOR»
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/EnumerationTypeGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/EnumerationTypeGen.xtend
index fc0ef2376..afdd44e88 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/EnumerationTypeGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/EnumerationTypeGen.xtend
@@ -58,7 +58,7 @@ class EnumerationTypeGen {
 		
 		#include "etDatatypes.h"
 		
-		«IF et.getPrimitiveType()!=null»
+		«IF et.getPrimitiveType()!==null»
 			«FOR lit: et.literals»
 				#define «et.name»_«lit.name» «lit.castedValue»
 			«ENDFOR»
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/Initialization.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/Initialization.xtend
index 31b8403ba..d5fde7c59 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/Initialization.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/Initialization.xtend
@@ -57,7 +57,7 @@ class Initialization {
 		var a = path.last
 		var aType = a.type.type
 		if(a.type.ref){
-			return if(a.defaultValueLiteral != null)
+			return if(a.defaultValueLiteral !== null)
 				a.defaultValueLiteral
 			else
 				languageExt.nullPointer
@@ -71,7 +71,7 @@ class Initialization {
 						«ENDFOR»
 					}'''
 			ExternalType:
-				if(a.defaultValueLiteral != null)
+				if(a.defaultValueLiteral !== null)
 					a.defaultValueLiteral
 				else
 					languageExt.defaultValue(aType)
@@ -96,17 +96,17 @@ class Initialization {
 	
 	def private getPrimitiveValue(InstanceBase instance, List<Attribute> path){
 		var value = path.getAttrInstanceConfigValue(instance)
-		if(value == null)
+		if(value === null)
 			value = switch instance {
 				ActorInstance: path.getAttrClassConfigValue(instance.actorClass, true)
 				InterfaceItemInstance: path.getAttrClassConfigValue(getPortClass(instance.interfaceItem))
 			}
-		if(value == null)
+		if(value === null)
 			value = path.last.defaultValueLiteral
 		
 		var type = path.last.type.type
-		return if(value != null && type.primitive) languageExt.toValueLiteral(type as PrimitiveType, value)
-				else if(value != null && type.enumeration) languageExt.toEnumLiteral(type as EnumerationType, value)
+		return if(value !== null && type.primitive) languageExt.toValueLiteral(type as PrimitiveType, value)
+				else if(value !== null && type.enumeration) languageExt.toEnumLiteral(type as EnumerationType, value)
 				else languageExt.defaultValue(type)
 	}
 }
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeGen.xtend
index 08ebe71da..a48c066f8 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeGen.xtend
@@ -30,8 +30,8 @@ import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance
 import org.eclipse.etrice.core.genmodel.etricegen.PortInstance
 import org.eclipse.etrice.core.genmodel.etricegen.Root
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.CommunicationType
 import org.eclipse.etrice.core.room.EnumerationType
 import org.eclipse.etrice.core.room.Port
@@ -43,7 +43,6 @@ import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.c.Main
 import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo
 import org.eclipse.etrice.generator.fsm.base.IntelligentSeparator
-import org.eclipse.etrice.generator.generic.ILanguageExtension
 import org.eclipse.etrice.generator.generic.ProcedureHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.etrice.generator.generic.TypeHelpers
@@ -59,7 +58,6 @@ class NodeGen {
 
 	@Inject IGeneratorFileIo fileIO
 	@Inject Initialization attrInitGenAddon
-	@Inject ILanguageExtension languageExt
 	@Inject IDiagnostician diagnostician
 	@Inject ILogger logger;
 
@@ -67,7 +65,7 @@ class NodeGen {
 		for (nr : ETMapUtil::getNodeRefs()) {
 			for (instpath : ETMapUtil::getSubSystemInstancePaths(nr)) {
 				val ssi = root.getInstance(instpath) as SubSystemInstance
-				if (ssi!=null) {
+				if (ssi!==null) {
 					val filepath = ssi.subSystemClass.generationTargetPath+ssi.subSystemClass.getPath
 					val infopath = ssi.subSystemClass.generationInfoPath+ssi.subSystemClass.getPath
 					var file = nr.getCHeaderFileName(ssi)
@@ -418,7 +416,7 @@ class NodeGen {
 		// list of replicated interface items (all are event driven ports)
 		val replEventItems = new ArrayList<InterfaceItemInstance>()
 		replEventItems.addAll(ai.orderedIfItemInstances.filter(e|e.replicated))
-		val haveReplSubItems = replEventItems.findFirst(e|!e.peers.empty)!=null
+		val haveReplSubItems = replEventItems.findFirst(e|!e.peers.empty)!==null
 		val replEventPorts = replEventItems.filter(i|i.interfaceItem instanceof Port)
 		val replEventSPPs = replEventItems.filter(i|i.interfaceItem instanceof SPP)
 
@@ -555,7 +553,7 @@ class NodeGen {
 
 	def private genSendPortInitializer(InterfaceItemInstance pi) {
 		val pc = (pi as PortInstance).port.protocol as ProtocolClass
-		var messages = pc.allIncomingMessages.filter(m|m.data!=null)
+		var messages = pc.allIncomingMessages.filter(m|m.data!==null)
 		val enumMsgs = messages.filter(m|m.data.refType.type.isEnumeration)
 		val boolMsgs = messages.filter(m|m.data.refType.type.isBoolean)
 		val usesMSC = Main::settings.generateMSCInstrumentation && !(enumMsgs.empty && boolMsgs.empty)
@@ -577,7 +575,7 @@ class NodeGen {
 	}
 
 	def private getInterfaceItemInstanceData(InterfaceItemInstance pi){
-		if (pi.protocol.getPortClass(pi.conjugated)== null) return "NULL"
+		if (pi.protocol.getPortClass(pi.conjugated)=== null) return "NULL"
 		if (pi.protocol.getPortClass(pi.conjugated).attributes.empty){
 			return "NULL"
 		}else{
@@ -587,7 +585,7 @@ class NodeGen {
 
 
 	def private String genRecvPortInitializer(Root root, ActorInstance ai, InterfaceItemInstance pi) {
-		var sentMsgs = pi.interfaceItem.incoming.filter(m|m.data!=null)
+		var sentMsgs = pi.interfaceItem.incoming.filter(m|m.data!==null)
 		val enumMsgs = sentMsgs.filter(m|m.data.refType.type.isEnumeration)
 		val boolMsgs = sentMsgs.filter(m|m.data.refType.type.isBoolean)
 		val usesMSC = Main::settings.generateMSCInstrumentation && !(enumMsgs.empty && boolMsgs.empty)
@@ -777,7 +775,7 @@ class NodeGen {
 	}
 
 	def private createLoggerCall(PortInstance pi) {
-		val msg = pi.protocol.incomingMessages.filter(m|m.data!=null && m.data.refType.type.enumerationOrPrimitive).get(0)
+		val msg = pi.protocol.incomingMessages.filter(m|m.data!==null && m.data.refType.type.enumerationOrPrimitive).get(0)
 		val ai = pi.eContainer as ActorInstance
 		val data = ai.path.pathName+"."+pi.name+"."+msg.name
 		val type = if (msg.data.refType.type instanceof EnumerationType) LiteralType.INT
@@ -823,7 +821,7 @@ class NodeGen {
 								for (filter: filterList) {
 									if (path.matches(filter)) {
 										matched = true
-										if (!pi.protocol.incomingMessages.filter(m|m.data!=null && m.data.refType.type.enumerationOrPrimitive).empty) {
+										if (!pi.protocol.incomingMessages.filter(m|m.data!==null && m.data.refType.type.enumerationOrPrimitive).empty) {
 											result.add(pi)
 											primitive = true
 											logger.logInfo("    data driven port "+pi.path+" (matched "+filter+")");
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeRunnerGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeRunnerGen.xtend
index 3e56fdcd3..e54711c4d 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeRunnerGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/NodeRunnerGen.xtend
@@ -36,7 +36,7 @@ class NodeRunnerGen {
 		for (nr : ETMapUtil::getNodeRefs()) {
 			for (instpath : ETMapUtil::getSubSystemInstancePaths(nr)) {
 				val ssi = root.getInstance(instpath) as SubSystemInstance
-				if (ssi!=null) {
+				if (ssi!==null) {
 					val clsname = nr.name+"_"+ssi.name
 					fileAccess.setOutputPath(ssi.subSystemClass.generationTargetPath+ssi.subSystemClass.getPath)
 					fileAccess.generateFile( clsname+"_Runner.c", root.generateSourceFile(ssi, first))
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.xtend
index 7c973a7cb..143a1b249 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.xtend
@@ -16,7 +16,7 @@ package org.eclipse.etrice.generator.c.gen
 import com.google.inject.Inject
 import com.google.inject.Singleton
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.CommunicationType
 import org.eclipse.etrice.core.room.Operation
 import org.eclipse.etrice.core.room.ProtocolClass
@@ -120,7 +120,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 		
 		«generateIncludeGuardBegin(filename)»
 
-		«IF pc.base!=null»
+		«IF pc.base!==null»
 			// include base class utils
 			#include «pc.base.utilsIncludePath»
 			
@@ -143,7 +143,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 		val portClass = pc.getPortClass(conj)
 		val portClassName = pc.getPortClassName(conj)
 	'''
-		«IF portClass!=null»
+		«IF portClass!==null»
 			/* «IF conj»conjugate«ELSE»regular«ENDIF» port class */
 			
 			/* operations */
@@ -214,14 +214,14 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 				«allAttributes.attributes»
 			};
 			«FOR a:allAttributes»
-				«IF a.defaultValueLiteral!=null»
+				«IF a.defaultValueLiteral!==null»
 					«logger.logInfo(portClassName+" "+a.name+": Attribute initialization not supported in C")»
 				«ENDIF»
 			«ENDFOR»
 		«ENDIF»
 		
 		«FOR message : messages»
-			«var hasData = message.data!=null»
+			«var hasData = message.data!==null»
 			«var typeName = if (hasData) message.data.refType.type.typeName else ""»
 			«var refp = if (hasData && (!(message.data.refType.type.enumerationOrPrimitive)||(message.data.refType.ref))) "*" else ""»
 			«var data = if (hasData) ", "+typeName+refp+" data" else ""»
@@ -246,7 +246,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 
 	
 	def private genDataDrivenPortHeaders(ProtocolClass pc) {
-		var sentMsgs = pc.allIncomingMessages.filter(m|m.data!=null)
+		var sentMsgs = pc.allIncomingMessages.filter(m|m.data!==null)
 		val enumMsgs = sentMsgs.filter(m|m.data.refType.type.isEnumeration)
 		val boolMsgs = sentMsgs.filter(m|m.data.refType.type.isBoolean)
 		val usesMSC = Main::settings.generateMSCInstrumentation && !(enumMsgs.empty && boolMsgs.empty)
@@ -292,7 +292,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 			«pc.getPortClassName(false)»;
 			
 			«FOR message : sentMsgs»
-				«var hasData = message.data!=null»
+				«var hasData = message.data!==null»
 				«var typeName = if (hasData) message.data.refType.type.typeName else ""»
 				«var refp = if (hasData && !(message.data.refType.type.enumerationOrPrimitive)) "*" else ""»
 				«var data = if (hasData) ", "+typeName+refp+" data" else ""»
@@ -304,7 +304,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	}
 	
 	def private genDataDrivenPortSources(ProtocolClass pc) {
-		var messages = pc.allIncomingMessages.filter(m|m.data!=null)
+		var messages = pc.allIncomingMessages.filter(m|m.data!==null)
 		val enumMsgs = messages.filter(m|m.data.refType.type.isEnumeration)
 		val boolMsgs = messages.filter(m|m.data.refType.type.isBoolean)
 		val usesMSC = Main::settings.generateMSCInstrumentation && !(enumMsgs.empty && boolMsgs.empty)
@@ -358,7 +358,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 
 		'''
 			«FOR message : messages»
-				«var hasData = message.data!=null»
+				«var hasData = message.data!==null»
 				«var typeName = if (hasData) message.data.refType.type.typeName else ""»
 				«var refp = if (hasData && ((message.data.refType.ref))) "*" else ""»
 				«var refpd = if (hasData && (!(message.data.refType.type.enumerationOrPrimitive)||(message.data.refType.ref))) "*" else ""»
@@ -368,7 +368,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 				«var hdlr = message.getSendHandler(conj)»
 				
 				«messageSignature(portClassName, message.name, "", data)» {
-					«IF hdlr != null»
+					«IF hdlr !== null»
 						«AbstractGenerator::getInstance().getTranslatedCode(hdlr.detailCode)»
 					«ELSE»
 						ET_MSC_LOGGER_SYNC_ENTRY("«portClassName»", "«message.name»")
@@ -381,7 +381,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 				}
 				
 				«messageSignature(replPortClassName, message.name, "_broadcast", data)» {
-					«IF hdlr != null»
+					«IF hdlr !== null»
 						int i;
 						for (i=0; i<((etReplPort*)self)->size; ++i) {
 							«portClassName»_«message.name»(&((etReplPort*)self)->ports[i].port«dataCall»);
@@ -400,7 +400,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 				}
 				
 				«messageSignature(replPortClassName, message.name, "", ", int idx__et"+data)» {
-					«IF hdlr != null»
+					«IF hdlr !== null»
 						«portClassName»_«message.name»(&((etReplPort*)self)->ports[idx__et].port«dataCall»);
 					«ELSE»					
 						ET_MSC_LOGGER_SYNC_ENTRY("«replPortClassName»", "«message.name»")
diff --git a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/StateMachineGen.xtend b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/StateMachineGen.xtend
index 4d1fcc834..abdeb3fac 100644
--- a/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/StateMachineGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.c/src/org/eclipse/etrice/generator/c/gen/StateMachineGen.xtend
@@ -18,7 +18,10 @@ import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass
 import org.eclipse.etrice.generator.c.Main
 import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator
 import org.eclipse.etrice.generator.generic.RoomExtensions
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.fsm.fSM.State
 
 @Singleton
 class StateMachineGen extends GenericStateMachineGenerator {
@@ -27,8 +30,10 @@ class StateMachineGen extends GenericStateMachineGenerator {
 
 	def genHeaderConstants(ExpandedActorClass xpac) {
 		val ac = xpac.actorClass
-		/* TODO: can save one entry if NO_STATE=-1 but influences Java */
-		val historySize = xpac.stateMachine.baseStateList.size - xpac.stateMachine.leafStateList.size + 2
+		
+		// this is the C generator and thus we have all states and they are enumerated with non-leaf states first
+		// starting with the NUM_PREDEF_STATE_CONSTANTS for TOP and NO_STATE
+		val historySize = xpac.graphContainer.graph.allStateNodes.filter[!isLeaf].size + NUM_PREDEF_STATE_CONSTANTS
 		'''
 			/* constant for state machine data */
 			#define «ac.name.toUpperCase»_HISTORY_SIZE «historySize»
@@ -60,9 +65,10 @@ class StateMachineGen extends GenericStateMachineGenerator {
 	/**
 	 * @param generateImplementation NOT used
 	 */
-	override public genExtra(ExpandedModelComponent xpmc, boolean generateImplementation) {
-		val mc = xpmc.modelComponent
-		val states = xpmc.stateMachine.baseStateList.getLeafStatesLast
+	override public genExtra(GraphContainer gc, boolean generateImplementation) {
+		val mc = gc.component
+		val allStates = gc.graph.allStateNodes.map[stateGraphNode].filter(typeof(State)).toList
+		val states = allStates.getLeafStatesLast
 		'''
 			«IF Main::settings.generateMSCInstrumentation»
 				/* state names */
@@ -73,7 +79,7 @@ class StateMachineGen extends GenericStateMachineGenerator {
 			«langExt.accessLevelPrivate»void setState(«mc.componentName»* self, «stateType» new_state) {
 				self->state = new_state;
 				«IF Main::settings.generateMSCInstrumentation»
-					ET_MSC_LOGGER_CHANGE_STATE(self->constData->instName, stateStrings[new_state])
+					ET_MSC_LOGGER_CHANGE_STATE(self->constData->instName, stateStrings[new_state]);
 				«ENDIF»
 			}
 
diff --git a/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/DataConfiguration.xtend b/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/DataConfiguration.xtend
index 362ad8ce3..4bfdf1894 100644
--- a/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/DataConfiguration.xtend
+++ b/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/DataConfiguration.xtend
@@ -27,10 +27,10 @@ import org.eclipse.etrice.core.config.ConfigValue
 import org.eclipse.etrice.core.config.ConfigValueArray
 import org.eclipse.etrice.core.config.EnumConfigValue
 import org.eclipse.etrice.core.config.LiteralConfigValue
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance
 import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.ProtocolClass
diff --git a/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/util/DataConfigurationHelper.java b/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/util/DataConfigurationHelper.java
index c369124db..63fd93b36 100644
--- a/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/util/DataConfigurationHelper.java
+++ b/plugins/org.eclipse.etrice.generator.config/src/org/eclipse/etrice/generator/config/util/DataConfigurationHelper.java
@@ -30,7 +30,7 @@ import org.eclipse.etrice.core.config.PortInstanceConfig;
 import org.eclipse.etrice.core.config.ProtocolClassConfig;
 import org.eclipse.etrice.core.config.SubSystemConfig;
 import org.eclipse.etrice.core.config.util.ConfigUtil;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.Attribute;
 import org.eclipse.etrice.core.room.DataClass;
diff --git a/plugins/org.eclipse.etrice.generator.cpp/.classpath b/plugins/org.eclipse.etrice.generator.cpp/.classpath
index ef5811bf8..87e8cd659 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/.classpath
+++ b/plugins/org.eclipse.etrice.generator.cpp/.classpath
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="xtend-gen"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="xtend-gen"/>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.etrice.generator.cpp/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.generator.cpp/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.generator.cpp/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.generator.cpp/META-INF/MANIFEST.MF
index ff597c263..5af209e91 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.generator.cpp/META-INF/MANIFEST.MF
@@ -14,7 +14,8 @@ Require-Bundle: org.eclipse.etrice.core.genmodel;bundle-version="1.1.3",
  org.eclipse.etrice.generator.doc;bundle-version="1.1.3",
  org.eclipse.xtend.lib;bundle-version="2.6.0",
  org.eclipse.xtext.generator;bundle-version="2.6.0",
- org.eclipse.xtext.util;bundle-version="2.6.0"
+ org.eclipse.xtext.util;bundle-version="2.6.0",
+ org.eclipse.etrice.core.genmodel.fsm
 Import-Package: org.apache.log4j
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.eclipse.etrice.generator.cpp,
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.xtend b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.xtend
index 6ff717e2d..2791ee88a 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.xtend
@@ -19,6 +19,7 @@ import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType
 import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass
 import org.eclipse.etrice.core.genmodel.etricegen.Root
 import org.eclipse.etrice.core.genmodel.etricegen.WiredActorClass
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.generator.cpp.Main
 import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers
@@ -158,16 +159,16 @@ class ActorClassGen extends GenericActorClassGenerator {
 				virtual void destroy();
 
 				«IF ac.hasNonEmptyStateMachine»
-					«xpac.genStateMachineConstants»
+					«xpac.graphContainer.genStateMachineConstants»
 
-					«xpac.genStateMachineMethods(false)»
+					«xpac.graphContainer.genStateMachineMethods(false)»
 					«IF ac.commType == ComponentCommunicationType::DATA_DRIVEN»
 						void receiveEvent(etRuntime::InterfaceItemBase* ifitem, int evt, void* generic_data);
 					«ENDIF»
 					«IF ac.commType == ComponentCommunicationType::ASYNCHRONOUS || ac.commType == ComponentCommunicationType::DATA_DRIVEN»
 						virtual void receive(const etRuntime::Message* msg);
 					«ENDIF»
-				«ELSEIF xpac.stateMachine.empty»
+				«ELSEIF FsmGenExtensions.isEmpty(xpac.graphContainer.graph)»
 «««					no state machine in the super classes
 					//--------------------- no state machine
 					virtual void receiveEvent(etRuntime::InterfaceItemBase* ifitem, int evt, void* data);
@@ -347,7 +348,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 		«operationsImplementation(ac.operations, ac.name)»
 
 		«IF ac.hasNonEmptyStateMachine»
-			«xpac.genStateMachineMethods(true)»
+			«xpac.graphContainer.genStateMachineMethods(true)»
 			«IF ac.commType == ComponentCommunicationType::DATA_DRIVEN»
 				void «ac.name»::receiveEvent(InterfaceItemBase* ifitem, int evt, void* generic_data) {
 					handleSystemEvent(ifitem, evt, generic_data);
@@ -362,7 +363,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 					«ENDIF»
 				}
 			«ENDIF»
-		«ELSEIF xpac.stateMachine.empty»
+		«ELSEIF FsmGenExtensions.isEmpty(xpac.graphContainer.graph)»
 «««			no state machine in the super classes
 			//--------------------- no state machine
 			void «ac.name»::receiveEvent(InterfaceItemBase* ifitem, int evt, void* data) {
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppExtensions.xtend b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppExtensions.xtend
index c788cd293..0020d5d42 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppExtensions.xtend
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppExtensions.xtend
@@ -24,16 +24,16 @@ import java.util.List
 import org.eclipse.emf.ecore.EObject
 import org.eclipse.etrice.core.etphys.eTPhys.NodeRef
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.DataType
 import org.eclipse.etrice.core.room.EnumLiteral
 import org.eclipse.etrice.core.room.EnumerationType
 import org.eclipse.etrice.core.room.ExternalType
 import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageData
 import org.eclipse.etrice.core.room.PrimitiveType
 import org.eclipse.etrice.core.room.RoomClass
-import org.eclipse.etrice.core.room.VarDecl
 import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.generic.ILanguageExtension
 import org.eclipse.etrice.generator.generic.RoomExtensions
@@ -50,7 +50,7 @@ class CppExtensions implements ILanguageExtension {
 	@Inject extension RoomExtensions
 
 	override String getTypedDataDefinition(EObject msg) {
-		generateArglistAndTypedData((msg as Message).data).get(1)
+		generateArglistAndTypedData((msg as Message).data).get(TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal)
 	}
 
 	def String getCppHeaderFileName(RoomClass rc) { rc.name + ".h" }
@@ -202,10 +202,11 @@ class CppExtensions implements ILanguageExtension {
 	}
 
 	override generateArglistAndTypedData(EObject d) {
-		if (d==null || !(d instanceof VarDecl))
+		// TODO 529445: d will be a RefableType, not MessageData
+		if (d===null || !(d instanceof MessageData))
 			return newArrayList("", "", "")
 
-		val data = d as VarDecl
+		val data = d as MessageData
 
 		val castExpr = switch it : data.refType.type {
 			PrimitiveType case !Strings.isEmpty(castName): castName
@@ -219,15 +220,15 @@ class CppExtensions implements ILanguageExtension {
 		}
 		var deRef = if(!data.refType.ref) '*' else ''
 
-		val typedData = '''«typeExpr» «data.name» = «deRef»(static_cast<«castExpr»>(generic_data__et));''' + NEWLINE
-		val dataArg = ''', «data.name»'''
-		val typedArgList = ''', «typeExpr» «data.name»'''
+		val dataArg = ''', «GENERIC_DATA_NAME»'''
+		val typedData = '''«typeExpr» «GENERIC_DATA_NAME» = «deRef»(static_cast<«castExpr»>(generic_data__et));''' + NEWLINE
+		val typedArgList = ''', «typeExpr» «GENERIC_DATA_NAME»'''
 
 		return #[dataArg, typedData, typedArgList]
 	}
 
 	override getTargetType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
+		if (type.getPrimitiveType()!==null)
 			type.getPrimitiveType().getTargetName()
 		else
 			type.getName()
@@ -237,14 +238,14 @@ class CppExtensions implements ILanguageExtension {
 		val type = literal.eContainer() as EnumerationType
 		val cast = type.targetType
 
-		if (type.primitiveType!=null)
+		if (type.primitiveType!==null)
 			Long.toString(literal.getLiteralValue())
 		else
 			"(("+cast+")"+Long.toString(literal.getLiteralValue())+")"
 	}
 
 	override getCastType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
+		if (type.getPrimitiveType()!==null)
 			type.getPrimitiveType().getCastName()
 		else
 			type.getName()
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppTranslationProvider.java b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppTranslationProvider.java
index 5b04cf94f..40c5d2c31 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/CppTranslationProvider.java
@@ -12,7 +12,7 @@
 
 package org.eclipse.etrice.generator.cpp.gen;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
@@ -39,7 +39,7 @@ public class CppTranslationProvider extends DefaultTranslationProvider {
 	}
 
 	@Override
-	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, ArrayList<String> args, String index, String orig) {
+	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, List<String> args, String index, String orig) {
 		if (index==null)
 			return orig;
 
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/DataClassGen.xtend b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/DataClassGen.xtend
index 105f639fc..c629ccef3 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/DataClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/DataClassGen.xtend
@@ -16,13 +16,13 @@ import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.util.List
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.ComplexType
 import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.xtext.generator.JavaIoFileSystemAccess
-import org.eclipse.etrice.core.room.util.RoomHelpers
 
 @Singleton
 class DataClassGen {
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.xtend b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.xtend
index 38f0da881..561a2f69d 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.xtend
@@ -16,7 +16,7 @@ import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.util.List
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.CommunicationType
 import org.eclipse.etrice.core.room.InterfaceItem
 import org.eclipse.etrice.core.room.Message
@@ -32,6 +32,7 @@ import org.eclipse.etrice.generator.generic.GenericProtocolClassGenerator
 import org.eclipse.etrice.generator.generic.ProcedureHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.etrice.generator.generic.TypeHelpers
+import org.eclipse.etrice.generator.generic.ILanguageExtension
 
 @Singleton
 class ProtocolClassGen extends GenericProtocolClassGenerator {
@@ -131,7 +132,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	// «IF conj»conjugated «ENDIF»port class
 	//------------------------------------------------------------------------------------------------------------
 	class «portClassName» : public etRuntime::PortBase {
-		«IF pclass!=null»
+		«IF pclass!==null»
 			«pclass.userCode.userCode»
 		«ENDIF»
 	   public:
@@ -144,7 +145,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 
 		 virtual void receive(const etRuntime::Message* m);
 
-		«IF pclass!=null»
+		«IF pclass!==null»
 			«pclass.attributes.attributes»
 			«pclass.operations.operationsDeclaration(portClassName)»
 		«ENDIF»
@@ -251,7 +252,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	«portClassName»::«portClassName»(IInterfaceItemOwner* actor, const String& name, int localId, int idx)
 		«pclass.generateConstructorInitalizerList('idx')»
 	{
-		«IF pclass != null»«initHelper.genExtraInitializers(pclass.attributes)»«ENDIF»
+		«IF pclass !== null»«initHelper.genExtraInitializers(pclass.attributes)»«ENDIF»
 	}
 	«IF Main::settings.generateMSCInstrumentation»
 
@@ -291,7 +292,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 		«ENDIF»
 	}
 
-	«IF pclass!=null»
+	«IF pclass!==null»
 		«pclass.operations.operationsImplementation(portClassName)»
 	«ENDIF»
 
@@ -335,34 +336,34 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 		val List<CharSequence> initList = newArrayList
 
 		initList += '''PortBase(actor, name, localId, «index»)'''
-		if(pc != null)
+		if(pc !== null)
 			initList += pc.attributes.map['''«name»(«initializerListValue»)''']
 
 		initList.generateCtorInitializerList
 	}
 
 	def protected messageCall(Message m, boolean impl) {
-		'''«m.name»«IF impl»_impl«ENDIF»(«IF m.data!=null» «m.data.name»«ENDIF»)'''
+		'''«m.name»«IF impl»_impl«ENDIF»(«IF m.data!==null» «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»)'''
 	}
 
 
 	def protected messageSignature(Message m, boolean impl) {
-		'''«IF m.priv||impl»private:«ELSE»public:«ENDIF» void «m.name»«IF impl»_impl«ENDIF»(«IF m.data!=null»«m.data.refType.signatureString» «m.data.name»«ENDIF»)'''
+		'''«IF m.priv||impl»private:«ELSE»public:«ENDIF» void «m.name»«IF impl»_impl«ENDIF»(«IF m.data!==null»«m.data.refType.signatureString» «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»)'''
 	}
 
 	def protected messageSignatureDefinition(Message m, String classPrefix, boolean impl) {
-		'''void «classPrefix»::«m.name»«IF impl»_impl«ENDIF»(«IF m.data!=null»«m.data.refType.signatureString» «m.data.name»«ENDIF»)'''
+		'''void «classPrefix»::«m.name»«IF impl»_impl«ENDIF»(«IF m.data!==null»«m.data.refType.signatureString» «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»)'''
 	}
 
 	def protected sendMessage(Message m, String portClassName, String classPrefix, boolean conj) {
 		var dir = if (conj) "IN" else "OUT"
 		var hdlr = m.getSendHandler(conj)
-		val dataArg = if(m.data != null) ''', «m.data.name»'''
-		val messageType = if(m.data != null && !m.data.refType.ref) '''DataMessage<«m.data.refType.type.typeName»>''' else '''Message'''
+		val dataArg = if(m.data !== null) ''', «ILanguageExtension.GENERIC_DATA_NAME»'''
+		val messageType = if(m.data !== null && !m.data.refType.ref) '''DataMessage<«m.data.refType.type.typeName»>''' else '''Message'''
 		val message = '''new (buffer) «messageType»(getPeerAddress(), «portClassName»::«dir»_«m.name»«dataArg?:''»)'''
 		'''
 			«messageSignatureDefinition(m, classPrefix, false)» {
-				«IF hdlr!=null»
+				«IF hdlr!==null»
 					«FOR command : hdlr.detailCode.lines»	«command»
 					«ENDFOR»
 				«ELSE»
@@ -389,7 +390,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 
 
 	def protected generateDataDrivenHeaderFile(Root root, ProtocolClass pc) {
-		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!=null)
+		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!==null)
 		'''
 			/**
 			 * @author generated by eTrice
@@ -464,7 +465,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	}
 
 	def protected generateDataDrivenSourceFile(Root root, ProtocolClass pc) {
-		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!=null)
+		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!==null)
 		'''
 			/**
 			 * @author generated by eTrice
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.xtend b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.xtend
index 514cd75db..5af70d5a6 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.xtend
@@ -13,29 +13,26 @@
 
 package org.eclipse.etrice.generator.cpp.gen
 
-import com.google.inject.Inject
 import com.google.inject.Singleton
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
+import java.util.Comparator
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
 import org.eclipse.etrice.generator.cpp.Main
 import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator
-import org.eclipse.etrice.generator.generic.RoomExtensions
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
 
 @Singleton
 class StateMachineGen extends GenericStateMachineGenerator {
 
-	@Inject extension RoomExtensions
-
-	override genExtra(ExpandedModelComponent xpac, boolean generateImplementation) {
-		val states = newArrayList
-		var ac = xpac.modelComponent
-		val clsName = xpac.modelComponent.componentName
+	val nodeComparator = new NodeComparator
+	
+	override genExtra(GraphContainer gc, boolean generateImplementation) {
+		var ac = gc.component
+		val clsName = ac.componentName
+		val orderedStateNodes = gc.graph.allStateNodes.toList.sortWith(nodeComparator)
 
-//		it is crucial that we obey the order that is used for state IDs
-//		that means we have to collect base classes first and each base class list with leaf states last
-		while (ac!=null) {
-			states.addAll(0, ac.allBaseStates.leafStatesLast)
-			ac = ac.base
-		}
 		if(generateImplementation)
 			'''
 				«IF Main::settings.generateMSCInstrumentation || Main::settings.generateWithVerboseOutput»
@@ -43,12 +40,12 @@ class StateMachineGen extends GenericStateMachineGenerator {
 					const String «clsName»::s_stateStrings[] = {
 						"<no state>",
 						"<top>",
-						«FOR state : states SEPARATOR ","»
-							"«state.genStatePathName»"
+						«FOR state : orderedStateNodes SEPARATOR ","»
+							"«(state.stateGraphNode as State).genStatePathName»"
 						«ENDFOR»
 					};
 				«ENDIF»
-				const int «clsName»::s_numberOfStates = «2+states.size»;
+				const int «clsName»::s_numberOfStates = «2+orderedStateNodes.size»;
 
 				void «clsName»::setState(int new_state) {
 					«IF Main::settings.generateMSCInstrumentation»
@@ -69,7 +66,7 @@ class StateMachineGen extends GenericStateMachineGenerator {
 				«ENDIF»
 				static const int s_numberOfStates;
 
-				int history[«2+states.size»];
+				int history[«2+orderedStateNodes.size»];
 
 				void setState(int new_state);
 			'''
@@ -83,4 +80,27 @@ class StateMachineGen extends GenericStateMachineGenerator {
 		"etBool"
 	}
 
+	private static class NodeComparator implements Comparator<Node> {
+		
+		// it is crucial that we obey the order that is used for state IDs
+		// that means we have to collect base classes first and each base class list with leaf states last
+		override int compare(Node o1, Node o2) {
+			if (o1.inheritanceLevel==o2.inheritanceLevel) {
+				if (o1.isLeaf && o2.isLeaf) {
+					return 0
+				}
+				if (o1.isLeaf) {
+					return 1
+				}
+				if (o2.isLeaf) {
+					return -1
+				}
+				return 0
+			}
+			else {
+				return Integer.compare(o1.inheritanceLevel, o1.inheritanceLevel)
+			}
+		}
+		
+	}
 }
diff --git a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/Validator.java b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/Validator.java
index e813049dd..3d065a596 100644
--- a/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/Validator.java
+++ b/plugins/org.eclipse.etrice.generator.cpp/src/org/eclipse/etrice/generator/cpp/gen/Validator.java
@@ -13,7 +13,7 @@
 package org.eclipse.etrice.generator.cpp.gen;
 
 import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 
 import com.google.inject.Inject;
 
diff --git a/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/DocGen.xtend b/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/DocGen.xtend
index 4f39be2e8..d41f3c632 100644
--- a/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/DocGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/DocGen.xtend
@@ -21,7 +21,6 @@ import org.eclipse.etrice.core.common.base.Documentation
 import org.eclipse.etrice.core.common.base.util.RelativePathHelpers
 import org.eclipse.etrice.core.fsm.fSM.State
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.CompoundProtocolClass
@@ -38,6 +37,7 @@ import org.eclipse.etrice.core.room.util.RoomHelpers
 import org.eclipse.etrice.generator.fsm.base.CodegenHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.xtext.generator.JavaIoFileSystemAccess
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 
 @Singleton
 class DocGen {
@@ -276,7 +276,7 @@ class DocGen {
 	'''
 		\level{2} {«dc.name.escapedString»}
 		«dc.docu.generateDocText»
-		«IF dc.primitiveType!=null»
+		«IF dc.primitiveType!==null»
 			The literals of this enumeration are based on PrimitiveType «dc.primitiveType.name.escapedString».
 		«ELSE»
 			The literals of this enumeration are of type \texttt{int}.
@@ -311,24 +311,24 @@ class DocGen {
 		«IF !pc.allIncomingMessages.empty»
 			\level{3}{Incoming Messages}
 			
-			\begin{tabular}[ht]{|l|l|l|p{8cm}|}
+			\begin{tabular}[ht]{|l|l|p{8cm}|}
 			\hline
-			Message & Data & Type & Description\\
+			Message & Type & Description\\
 			«FOR ims : pc.allIncomingMessages»
 				\hline
-				«ims.name.escapedString» & «IF ims.data != null» «ims.data.name.escapedString» «ENDIF» & «IF ims.data != null» «ims.data.refType.type.name.escapedString» «ENDIF» & «ims.docu.generateDocText»\\
+				«ims.name.escapedString» & «IF ims.data !== null» «ims.data.refType.type.name.escapedString» «ENDIF» & «ims.docu.generateDocText»\\
 			«ENDFOR»
 			\hline
 			\end{tabular}
 		«ENDIF»
 		«IF !pc.allOutgoingMessages.empty»
 			\level{3}{Outgoing Messages}
-			\begin{tabular}[ht]{|l|l|l|p{8cm}|}
+			\begin{tabular}[ht]{|l|l|p{8cm}|}
 			\hline
-			Message & Data & Type & Description\\
+			Message & Type & Description\\
 			«FOR oms : pc.allOutgoingMessages»
 				\hline
-				«oms.name.escapedString» & «IF oms.data != null» «oms.data.name.escapedString» «ENDIF» & «IF oms.data != null» «oms.data.refType.type.name.escapedString» «ENDIF» & «oms.docu.generateDocText»\\
+				«oms.name.escapedString» & «IF oms.data !== null» «oms.data.refType.type.name.escapedString» «ENDIF» & «oms.docu.generateDocText»\\
 			«ENDFOR»
 			\hline
 			\end{tabular}
@@ -363,7 +363,7 @@ class DocGen {
 			\level{3}{Structure}
 			«ac.structureDocu.generateDocText»
 			«includeGraphics(filename.imagePath,IMGWIDTH_DEFAULT,ac.name + " Structure")»
-		«ELSEIF ac.structureDocu != null»
+		«ELSEIF ac.structureDocu !== null»
 			\level{3}{Structure}
 			«ac.structureDocu.generateDocText»
 		«ENDIF»
@@ -381,7 +381,7 @@ class DocGen {
 			\level{3}{Behavior}
 			«ac.behaviorDocu.generateDocText»
 			«generateFsmDoc(ctx.model, ac)»
-		«ELSEIF ac.behaviorDocu != null»
+		«ELSEIF ac.behaviorDocu !== null»
 			\level{3}{Behavior}
 			«ac.behaviorDocu.generateDocText»
 		«ENDIF»
@@ -408,7 +408,7 @@ class DocGen {
 		
 		\begin{par}
 		«FOR s : ac.stateMachine.states»
-			«IF s.docu != null»	
+			«IF s.docu !== null»	
 				\textbf{State description} \textit{«s.genStatePathName.replaceAll("_","\\\\_")»}:
 				\newline
 				«generateDocText(s.docu)»
@@ -417,7 +417,7 @@ class DocGen {
 		«ENDFOR»
 
 		«FOR c : ac.stateMachine.chPoints»
-			«IF c.docu != null»
+			«IF c.docu !== null»
 				\textbf{Choicepoint description} \textit{«c.name.escapedString»}:
 				\newline
 				«generateDocText(c.docu)»
@@ -482,7 +482,7 @@ class DocGen {
 		
 		\begin{par}
 		«FOR s : state.subgraph.states»
-			«IF s.docu != null»	
+			«IF s.docu !== null»	
 				\textbf{State description} \textit{«s.genStatePathName.replaceAll("_","\\\\_")»}:
 				\newline
 				«generateDocText(s.docu)»
@@ -491,7 +491,7 @@ class DocGen {
 		«ENDFOR»
 
 		«FOR c : state.subgraph.chPoints»
-			«IF c.docu != null»
+			«IF c.docu !== null»
 				\textbf{Choicepoint description} \textit{«c.name.escapedString»}:
 				\newline
 				«generateDocText(c.docu)»
@@ -531,10 +531,10 @@ class DocGen {
 			\hline		
 				Name: & «op.name.escapedString»\\
 				\hline
-				ReturnType: &  «IF op.returnType != null»«op.returnType.type.name.escapedString»«ELSE»void«ENDIF»\\
+				ReturnType: &  «IF op.returnType !== null»«op.returnType.type.name.escapedString»«ELSE»void«ENDIF»\\
 				\hline
 				Arguments: & «FOR pa : op.arguments SEPARATOR ", "»«pa.name.escapedString»:«pa.refType.type.name.escapedString»«ENDFOR»\\
-				«IF op.docu != null»
+				«IF op.docu !== null»
 					\hline
 					«IF op.docu.toString.length > 85»
 						\multicolumn{2} {|p{13cm}|} {«generateDocText(op.docu)»}\\
@@ -551,7 +551,7 @@ class DocGen {
 	
 	def private generateDocText(Documentation doc){
 		'''
-		«IF doc!=null»
+		«IF doc!==null»
 			% begin text from user Documentation
 			«FOR line: doc.lines»
 				«line.escapedString»
diff --git a/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.xtend b/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.xtend
index d9736d0b2..7c768618b 100644
--- a/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.doc/src/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.xtend
@@ -15,7 +15,6 @@ package org.eclipse.etrice.generator.doc.gen
 import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.io.File
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
 import org.eclipse.etrice.core.genmodel.etricegen.AbstractInstance
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInterfaceInstance
@@ -27,6 +26,7 @@ import org.eclipse.xtext.generator.JavaIoFileSystemAccess
 
 import static java.lang.Runtime.*
 import org.eclipse.etrice.core.etmap.util.ETMapUtil
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 
 @Singleton
 class InstanceDiagramGen {
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/CodegenHelpers.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/CodegenHelpers.java
index 891c6c789..4b7d5f8a3 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/CodegenHelpers.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/CodegenHelpers.java
@@ -15,9 +15,9 @@ package org.eclipse.etrice.generator.fsm.base;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
 import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
 
 /**
  * @author Henrik Rentz-Reichert
@@ -32,7 +32,7 @@ public class CodegenHelpers {
 	 * @param t a {@link Transition}
 	 * @return a name for the action code operation the generator will generate
 	 */
-	public String getActionCodeOperationName(Transition t) {
+	public String getActionCodeOperationName(TransitionBase t) {
 		return "action_"+fsmNameProvider.getFullPath(t);
 	}
 	
@@ -61,11 +61,11 @@ public class CodegenHelpers {
 	}
 	
 	/**
-	 * @param tc a {@link TransitionChain}
+	 * @param tc a {@link Transition}
 	 * @return a name for the constant transition chain ID the generator will generate
 	 */
-	public String getGenChainId(TransitionChain tc) {
-		return "CHAIN_"+fsmNameProvider.getFullPath(tc.getTransition());
+	public String getGenChainId(TransitionBase tc) {
+		return "CHAIN_"+fsmNameProvider.getFullPath(tc);
 	}
 	
 	/**
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/DefaultFSMTranslationProvider.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/DefaultFSMTranslationProvider.java
index a96374d8f..10fcc4dc5 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/DefaultFSMTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/DefaultFSMTranslationProvider.java
@@ -12,14 +12,14 @@
 
 package org.eclipse.etrice.generator.fsm.base;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.DetailCode;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
 import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 
 import com.google.inject.Inject;
 
@@ -58,11 +58,11 @@ public class DefaultFSMTranslationProvider implements IFSMTranslationProvider {
 
 	/**
 	 * @return the original String
-	 * @see org.eclipse.etrice.generator.base.ITranslationProvider#getInterfaceItemMessageText(org.eclipse.etrice.core.room.InterfaceItem, org.eclipse.etrice.core.room.Message, java.util.ArrayList, java.lang.String, java.lang.String)
+	 * @see org.eclipse.etrice.generator.base.ITranslationProvider#getInterfaceItemMessageText(org.eclipse.etrice.core.room.InterfaceItem, org.eclipse.etrice.core.room.Message, java.util.List, java.lang.String, java.lang.String)
 	 */
 	@Override
 	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject msg,
-			ArrayList<String> args, String index, String orig) {
+			List<String> args, String index, String orig) {
 				return orig;
 			}
 
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Diagnostician.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Diagnostician.java
index a9f31a71e..832693c9e 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Diagnostician.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Diagnostician.java
@@ -15,7 +15,7 @@ package org.eclipse.etrice.generator.fsm.base;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
 
 import com.google.inject.Inject;
 
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IFSMTranslationProvider.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IFSMTranslationProvider.java
index 1f643defd..dc98d0bb0 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IFSMTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IFSMTranslationProvider.java
@@ -12,7 +12,7 @@
 
 package org.eclipse.etrice.generator.fsm.base;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
@@ -49,7 +49,7 @@ public interface IFSMTranslationProvider {
 	void setContainerClass(EObject container);
 	
 	/**
-	 * @return true if translation should be applied to members (attributes, operations and port.msg
+	 * @return true if translation should be applied to members (attributes, operations and port.msg)
 	 */
 	boolean translateMembers();
 	
@@ -66,7 +66,7 @@ public interface IFSMTranslationProvider {
 	 * @param orig the original text
 	 * @return the translation
 	 */
-	String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject msg, ArrayList<String> args, String index, String orig);
+	String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject msg, List<String> args, String index, String orig);
 
 	/**
 	 * @return true if translations are provided for tags
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/ILineOutputLogger.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/ILineOutputLogger.java
index e3bddc633..6c6379337 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/ILineOutputLogger.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/ILineOutputLogger.java
@@ -12,7 +12,7 @@
 
 package org.eclipse.etrice.generator.fsm.base;
 
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 
 
 /**
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IncrementalGenerationFileIo.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IncrementalGenerationFileIo.java
index df4d68722..fab85969a 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IncrementalGenerationFileIo.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/IncrementalGenerationFileIo.java
@@ -17,7 +17,7 @@ import java.io.IOException;
 import java.util.zip.CRC32;
 
 import org.apache.commons.io.FileUtils;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
 import org.eclipse.xtext.util.RuntimeIOException;
 
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Logger.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Logger.java
index d18e660c5..9eadc3c07 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Logger.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/Logger.java
@@ -27,13 +27,25 @@ import org.eclipse.emf.ecore.util.EcoreUtil;
  */
 public class Logger implements ILineOutputLogger {
 
+	private int errors = 0;
 	private ILineOutput output = null;
+	
+	@Override
+	public boolean hasErrors() {
+		return errors!=0;
+	}
 
 	public void logInfo(String text) {
 		println("Info: " + text);
 	}
 
+	@Override
+	public void logError(String text) {
+		logError(text, null);
+	}
+
 	public void logError(String text, EObject obj) {
+		++errors;
 		if (obj == null)
 			println("Error: " + text);
 		else {
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/NullLogger.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/NullLogger.java
index 73c475986..2aec3f0e7 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/NullLogger.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/base/NullLogger.java
@@ -1,16 +1,29 @@
 package org.eclipse.etrice.generator.fsm.base;
 
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 
 public class NullLogger implements ILogger {
 
+	private int errors = 0;
+	
     @Override
     public void logInfo(String text) {
     }
 
     @Override
     public void logError(String text, EObject obj) {
+    	++errors;
     }
 
+	@Override
+	public void logError(String text) {
+    	++errors;
+	}
+
+	@Override
+	public boolean hasErrors() {
+		return errors!=0;
+	}
+
 }
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.xtend b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.xtend
index f86f9679a..d772b9a3e 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.xtend
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.xtend
@@ -13,225 +13,241 @@
 package org.eclipse.etrice.generator.fsm.generic
 
 import com.google.inject.Inject
-import java.util.ArrayList
-import java.util.List
 import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType
 import org.eclipse.etrice.core.fsm.fSM.GuardedTransition
+import org.eclipse.etrice.core.fsm.fSM.MessageFromIf
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent
 import org.eclipse.etrice.core.fsm.fSM.State
 import org.eclipse.etrice.core.fsm.fSM.Transition
 import org.eclipse.etrice.core.fsm.fSM.TransitionPoint
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider
 import org.eclipse.etrice.core.fsm.util.FSMHelpers
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ActiveTrigger
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.util.FsmGenUtil
+import org.eclipse.etrice.core.genmodel.fsm.TriggerExtensions
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.CommonTrigger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
 import org.eclipse.etrice.generator.fsm.base.CodegenHelpers
 import org.eclipse.xtext.util.Pair
 
 import static org.eclipse.xtext.util.Tuples.*
 
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+import java.util.ArrayList
+
 /**
  * @author Henrik Rentz-Reichert
  *
  */
 abstract class AbstractStateMachineGenerator {
 
-    @Inject public extension FSMHelpers
-    @Inject public extension FsmGenUtil
-    @Inject public extension CodegenHelpers
-    @Inject public extension FSMExtensions
-    @Inject public ILanguageExtensionBase langExt
-    @Inject public IMessageIdGenerator msgIdGen
-    @Inject public IIfItemIdGenerator itemIdGen
+	protected static val NUM_PREDEF_STATE_CONSTANTS = 2
+	
+	@Inject public extension FSMHelpers
+	@Inject public extension CodegenHelpers
+	@Inject public extension FSMExtensions
+	@Inject public ILanguageExtensionBase langExt
+	@Inject public IMessageIdGenerator msgIdGen
+	@Inject public IIfItemIdGenerator itemIdGen
 	@Inject public TransitionChainGenerator transitionChainGenerator
 	@Inject public IDetailCodeTranslator translator
-
-    /**
-     * generates trigger IDs.
-     * Inheritance (if available) is used for base class IDs.
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @return the generated code
-     */
-    def public String genTriggerConstants(ExpandedModelComponent xpmc) {
-        xpmc.genTriggerConstants(langExt.usesInheritance)
-    }
-
-    /**
-     * generates trigger IDs.
-     * Inheritance (if available) is used for base class IDs.
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param omitBase use <code>true</code> if no base class trigger constants are needed
-     *
-     * @return the generated code
-     */
-    def public String genTriggerConstants(ExpandedModelComponent xpmc, boolean omitBase) {
-        val triggers = if (omitBase)
-                    xpmc.modelComponent.ownMessagesFromInterfaces
-                    else xpmc.modelComponent.allMessagesFromInterfaces
-
-        val list = new ArrayList<Pair<String, String>>()
-        list.add(pair("POLLING", "0"));
-        for (mif : triggers) {
-        	if (mif.from.eventDriven) {
-	            list.add(pair(xpmc.getTriggerCodeName(mif), itemIdGen.getIfItemId(mif.from)+" + EVT_SHIFT*"+msgIdGen.getMessageID(mif)))
-        	}
-        }
-
-        return langExt.genEnumeration("triggers", list)
-    }
-
-    /**
-     * generates state ID constants.
-     * Inheritance (if available) is used for base class IDs.
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @return the generated code
-     */
-    def public genStateIdConstants(ExpandedModelComponent xpmc) {
-        xpmc.genStateIdConstants(langExt.usesInheritance)
-    }
-
-    /**
-     * generates state ID constants.
-     * Inheritance (if available) is used for base class IDs.
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param omitBase use <code>true</code> if no base class state constants are needed
-     *
-     * @return the generated code
-     */
-    def public genStateIdConstants(ExpandedModelComponent xpmc, boolean omitBase) {
-        val mc = xpmc.modelComponent
-        // with inheritance we exclude inherited base states
-        var offset = 2 + if (omitBase)
-            mc.getNumberOfInheritedBaseStates() else 0
-        var baseStates = if (omitBase)
-            mc.stateMachine.getBaseStateList else xpmc.stateMachine.getBaseStateList
-
-        baseStates = baseStates.leafStatesLast
-
-        var list = new ArrayList<Pair<String, String>>()
-        if (!omitBase) {
-            list.add(pair("NO_STATE","0"))
-            list.add(pair("STATE_TOP","1"))
-        }
-        for (state : baseStates) {
-            list.add(pair(state.getGenStateId, offset.toString))
-            offset = offset+1;
-        }
-        list.add(pair("STATE_MAX", offset.toString))
-
-        return langExt.genEnumeration("state_ids", list)
-    }
-
-    /**
-     * generates transition chain ID constants.
-     * Inheritance can't be used used for base class IDs because of corner cases
-     * where base class and derived class chain IDs deviate (see bug 501354).
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     *
-     * @return the generated code
-     */
-    def public genTransitionChainConstants(ExpandedModelComponent xpmc) {
-        xpmc.genTransitionChainConstants(false/*langExt.usesInheritance*/)
-    }
-
-    /**
-     * generates transition chain ID constants.
-     * Inheritance can't be used used for base class IDs because of corner cases
-     * where base class and derived class chain IDs deviate.
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param omitBase use <code>true</code> if no base class transition chain constants are needed
-     *
-     * @return the generated code
-     */
-    def public genTransitionChainConstants(ExpandedModelComponent xpmc, boolean omitBase) {
-        var chains = if (omitBase)
-            xpmc.getOwnTransitionChains() else xpmc.transitionChains
-        var offset = if (omitBase)
-            xpmc.getTransitionChains().size-chains.size else 0
-
-        var list = new ArrayList<Pair<String, String>>()
-        for (chain : chains) {
-            offset = offset+1;
-            list.add(pair(chain.genChainId, offset.toString))
-        }
-
-        return langExt.genEnumeration("ChainIDs", list)
-    }
-
-    /**
-     * generates entry and exit code for states
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
-     *
-     * @return the generated code
-     */
-    def public String genEntryAndExitCodes(ExpandedModelComponent xpmc, boolean generateImplementation) {
-        xpmc.genEntryAndExitCodes(generateImplementation, langExt.usesInheritance)
-    }
-
-    /**
-     * generates entry and exit code for states
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
-     * @param omitBase use <code>true</code> if no base class entry and exit codes are needed
-     *
-     * @return the generated code
-     */
-    def public String genEntryAndExitCodes(ExpandedModelComponent xpmc, boolean generateImplementation, boolean omitBase) {
-        '''
-        «FOR state : xpmc.stateMachine.getStateList()»
-            «IF !omitBase || xpmc.isOwnObject(state)»
-                «xpmc.genActionCodeMethods(state, generateImplementation)»
-            «ENDIF»
-        «ENDFOR»
-        '''
-    }
-
-    /**
-     * generates transition action codes
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
-     *
-     * @return the generated code
-     */
-    def public String genActionCodes(ExpandedModelComponent xpmc, boolean generateImplementation) {
-        xpmc.genActionCodes(generateImplementation, langExt.usesInheritance)
-    }
-
-    /**
-     * generates transition action codes
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
-     * @param omitBase use <code>true</code> if no base class action codes are needed
-     *
-     * @return the generated code
-     */
-    def public String genActionCodes(ExpandedModelComponent xpmc, boolean generateImplementation, boolean omitBase) {
-        '''
-        «FOR tr : xpmc.stateMachine.allTransitionsRecursive»
-            «IF (!omitBase || xpmc.isOwnObject(tr)) && tr.action.hasDetailCode»
-                «xpmc.genActionCodeMethod(tr, generateImplementation)»
-            «ENDIF»
-        «ENDFOR»
-        '''
-    }
-
-    def public String genStateSwitchMethods(ExpandedModelComponent xpmc, boolean generateImplementation) {
-		val mc = xpmc.modelComponent
+	@Inject public FSMNameProvider fsmNameProvider
+
+	/**
+	 * generates trigger IDs.
+	 * Inheritance (if available) is used for base class IDs.
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @return the generated code
+	 */
+	def public String genTriggerConstants(GraphContainer gc) {
+		gc.genTriggerConstants(langExt.usesInheritance)
+	}
+
+	/**
+	 * generates trigger IDs.
+	 * Inheritance (if available) is used for base class IDs.
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param omitBase use <code>true</code> if no base class trigger constants are needed
+	 *
+	 * @return the generated code
+	 */
+	def public String genTriggerConstants(GraphContainer gc, boolean omitBase) {
+		val triggers = if (omitBase)
+					gc.component.ownMessagesFromInterfaces
+					else gc.component.allMessagesFromInterfaces
+
+		val list = <Pair<String, String>>newArrayList
+		list.add(pair("POLLING", "0"));
+		for (mif : triggers) {
+			if (mif.from.eventDriven) {
+				list.add(pair(mif.triggerCodeName, itemIdGen.getIfItemId(mif.from)+" + EVT_SHIFT*"+msgIdGen.getMessageID(mif)))
+			}
+		}
+
+		return langExt.genEnumeration("triggers", list)
+	}
+	
+	def String getTriggerCodeName(MessageFromIf mif) {
+		return "TRIG_"+mif.from.name+"__"+fsmNameProvider.getMessageName(mif.message);
+	}
+
+	/**
+	 * generates state ID constants.
+	 * Inheritance (if available) is used for base class IDs.
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @return the generated code
+	 */
+	def public genStateIdConstants(GraphContainer gc) {
+		gc.genStateIdConstants(langExt.usesInheritance)
+	}
+
+	/**
+	 * generates state ID constants.
+	 * Inheritance (if available) is used for base class IDs.
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param omitBase use <code>true</code> if no base class state constants are needed
+	 *
+	 * @return the generated code
+	 */
+	def public genStateIdConstants(GraphContainer gc, boolean omitBase) {
+		// with inheritance we exclude inherited states
+		val allStateNodes = gc.graph.allStateNodes.toList // TODO: without toList this didn't work - why?
+		
+		// omitBase: base class constants are inherited, so we start at an offset of
+		//         NUM_PREDEF_STATE_CONSTANTS + #(inherited states)
+		// !omitBase: nothing is inherited, offset is just NUM_PREDEF_STATE_CONSTANTS
+		var offset = NUM_PREDEF_STATE_CONSTANTS + if (omitBase)
+			allStateNodes.filter[inherited].size else 0
+		
+		// considered are all states (case of !omitBase) or just the ones which are not inherited (case of omitBase)
+		var consideredStates = (if (omitBase)
+			allStateNodes.filter[!inherited] else allStateNodes).map[stateGraphNode].filter(typeof(State)).toList
+
+		// we sort them with the non leaf states last to have the history as short as possible
+		consideredStates = consideredStates.leafStatesLast.toList
+
+		var list = <Pair<String, String>>newArrayList
+		if (!omitBase) {
+			list.add(pair("NO_STATE","0"))
+			list.add(pair("STATE_TOP","1"))
+		}
+		for (state : consideredStates) {
+			list.add(pair(state.getGenStateId, offset.toString))
+			offset = offset+1;
+		}
+		list.add(pair("STATE_MAX", offset.toString))
+
+		return langExt.genEnumeration("state_ids", list)
+	}
+
+	/**
+	 * generates transition chain ID constants.
+	 * Inheritance can't be used used for base class IDs because of corner cases
+	 * where base class and derived class chain IDs deviate (see bug 501354).
+	 *
+	 * @param gc the {@link GraphContainer}
+	 *
+	 * @return the generated code
+	 */
+	def public genTransitionChainConstants(GraphContainer gc) {
+		gc.genTransitionChainConstants(false/*langExt.usesInheritance*/)
+	}
+
+	/**
+	 * generates transition chain ID constants.<br/><br/>
+	 * 
+	 * <b>Note:</b> Inheritance can't be used used for base class IDs because of corner cases
+	 * where base class and derived class chain IDs deviate.
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param omitBase use <code>true</code> if no base class transition chain constants are needed
+	 *
+	 * @return the generated code
+	 */
+	def public genTransitionChainConstants(GraphContainer gc, boolean omitBase) {
+		val chains = (if (omitBase)
+			gc.graph.allLinks.filter[!inherited] else gc.graph.allLinks).map[transition].filter[isChainHead].filter(typeof(Transition)).toList
+		var offset = if (omitBase)
+			gc.graph.allLinks.filter[inherited].size else 0
+
+		var list = <Pair<String, String>>newArrayList
+		for (chain : chains) {
+			offset = offset+1;
+			list.add(pair(chain.genChainId, offset.toString))
+		}
+
+		return langExt.genEnumeration("ChainIDs", list)
+	}
+
+	/**
+	 * generates entry and exit code for states
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
+	 *
+	 * @return the generated code
+	 */
+	def public String genEntryAndExitCodes(GraphContainer gc, boolean generateImplementation) {
+		gc.genEntryAndExitCodes(generateImplementation, langExt.usesInheritance)
+	}
+
+	/**
+	 * generates entry and exit code for states
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
+	 * @param omitBase use <code>true</code> if no base class entry and exit codes are needed
+	 *
+	 * @return the generated code
+	 */
+	def public String genEntryAndExitCodes(GraphContainer gc, boolean generateImplementation, boolean omitBase) {
+		val states = gc.graph.allStateNodes.filter[!omitBase || !inherited].toList
+		'''
+		«FOR state : states»
+			«gc.genActionCodeMethods(state, generateImplementation)»
+		«ENDFOR»
+		'''
+	}
+
+	/**
+	 * generates transition action codes
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
+	 *
+	 * @return the generated code
+	 */
+	def public String genActionCodes(GraphContainer gc, boolean generateImplementation) {
+		gc.genActionCodes(generateImplementation, langExt.usesInheritance)
+	}
+
+	/**
+	 * generates transition action codes
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param generateImplementation if <code>true</code> the implementation is generated, else the declaration
+	 * @param omitBase use <code>true</code> if no base class action codes are needed
+	 *
+	 * @return the generated code
+	 */
+	def public String genActionCodes(GraphContainer gc, boolean generateImplementation, boolean omitBase) {
+		val transitions = gc.graph.allLinks.filter[!omitBase || !inherited].filter[transition.action.hasDetailCode].toList
+		'''
+		«FOR tr : transitions»
+			«gc.genActionCodeMethod(tr, generateImplementation)»
+		«ENDFOR»
+		'''
+	}
+
+	def public String genStateSwitchMethods(GraphContainer gc, boolean generateImplementation) {
+		val mc = gc.component
 		val async = mc.commType==ComponentCommunicationType::ASYNCHRONOUS
 		val eventDriven = mc.commType==ComponentCommunicationType::EVENT_DRIVEN
-		val ifItemPtr = interfaceItemType()+langExt.pointerLiteral()
+		val ifItemPtr = interfaceItemType + langExt.pointerLiteral
 		val handleEvents = async || eventDriven
 		val chainIDScope = if (langExt.usesInheritance) mc.className+langExt.scopeSeparator else ""
 		val opScope = langExt.operationScope(mc.className, !generateImplementation)
@@ -258,8 +274,13 @@ abstract class AbstractStateMachineGenerator {
 								"const "+ifItemPtr
 							else
 								ifItemPtr
-		val usesHdlr = usesHandlerTrPoints(xpmc)
-        '''
+		val usesHdlr = usesHandlerTrPoints(gc)
+		val nodes = gc.graph.allStateNodes.toList.sortBy[(stateGraphNode as State).genStateId]
+		val state2node = newHashMap
+		nodes.forEach[state2node.put(stateGraphNode as State, it)]
+		val states = nodes.map[stateGraphNode].filter(typeof(State)).toList
+		val transitionChains = gc.graph.allLinks.filter[isChainHead].toList.sortBy[transition.genChainId]
+		'''
 		/**
 		 * calls exit codes while exiting from the current state to one of its
 		 * parent states while remembering the history
@@ -273,11 +294,11 @@ abstract class AbstractStateMachineGenerator {
 			«privAccess»void «opScopePriv»exitTo(«selfPtr»«stateType» current__et, «stateType» to«IF usesHdlr», «boolType» handler__et«ENDIF») {
 				while (current__et!=to) {
 					switch (current__et) {
-						«FOR state : xpmc.stateMachine.getBaseStateList()»
-							case «state.getGenStateId()»:
-								«IF state.hasExitCode(true)»«IF usesHdlr»if (!handler__et) «ENDIF»«state.getExitCodeOperationName()»(«langExt.selfPointer(false)»);«ENDIF»
-								«setHistory(state.getParentStateId(), state.getGenStateId())»;
-								current__et = «state.getParentStateId()»;
+						«FOR state : states»
+							case «state.getGenStateId»:
+								«IF state.hasExitCode(true)»«IF usesHdlr»if (!handler__et) «ENDIF»«state.exitCodeOperationName»(«langExt.selfPointer(false)»);«ENDIF»
+								«setHistory(state.parentStateId, state.genStateId)»;
+								current__et = «state.parentStateId»;
 								break;
 						«ENDFOR»
 						default:
@@ -300,11 +321,10 @@ abstract class AbstractStateMachineGenerator {
 		«IF generateImplementation»
 			«privAccess»«stateType» «opScopePriv»executeTransitionChain(«selfPtr»int chain__et«IF handleEvents», «constIfItemPtr» ifitem, «langExt.voidPointer» generic_data__et«ENDIF») {
 				switch (chain__et) {
-					«var allchains = xpmc.getTransitionChains()»
-					«FOR tc : allchains»
-						case «chainIDScope»«tc.genChainId»:
+					«FOR tc : transitionChains»
+						case «chainIDScope»«tc.transition.genChainId»:
 						{
-							«transitionChainGenerator.generateExecuteChain(xpmc, tc)»
+							«transitionChainGenerator.generateExecuteChain(gc, tc)»
 						}
 					«ENDFOR»
 						default:
@@ -327,8 +347,7 @@ abstract class AbstractStateMachineGenerator {
 		 */
 		«IF generateImplementation»
 			«privAccess»«stateType» «opScopePriv»enterHistory(«selfPtr»«stateType» state__et«IF usesHdlr», «boolType» handler__et«ENDIF») {
-				«val baseStateList = xpmc.stateMachine.baseStateList»
-				«val needsSkipVar = !baseStateList.filter(s|s.hasEntryCode(true)).empty»
+				«val needsSkipVar = !states.filter(s|s.hasEntryCode(true)).empty»
 				«IF needsSkipVar»
 					«boolType» skip_entry__et = «langExt.booleanConstant(false)»;
 				«ENDIF»
@@ -340,26 +359,26 @@ abstract class AbstractStateMachineGenerator {
 				}
 				while («langExt.booleanConstant(true)») {
 					switch (state__et) {
-						«FOR state : baseStateList»
-						case «state.getGenStateId()»:
-							«IF state.hasEntryCode(true)»if (!(skip_entry__et«IF usesHdlr» || handler__et«ENDIF»)) «state.getEntryCodeOperationName()»(«langExt.selfPointer(false)»);«ENDIF»
-							«IF state.isLeaf()»
+						«FOR state : states»
+						case «state.genStateId»:
+							«IF state.hasEntryCode(true)»if (!(skip_entry__et«IF usesHdlr» || handler__et«ENDIF»)) «state.entryCodeOperationName»(«langExt.selfPointer(false)»);«ENDIF»
+							«IF state.isLeaf»
 								/* in leaf state: return state id */
-								return «state.getGenStateId()»;
+								return «state.getGenStateId»;
 							«ELSE»
 								/* state has a sub graph */
-								«IF state.subgraph.hasInitTransition()»
+								«var sub_initt = state2node.get(state).subgraph.initialTransition»
+								«IF sub_initt!==null»
 									/* with init transition */
-									if («getHistory(state.getGenStateId())»==NO_STATE) {
-										«var sub_initt = state.subgraph.getInitTransition()»
-										state__et = executeTransitionChain(«langExt.selfPointer(true)»«chainIDScope»«xpmc.getChain(sub_initt).genChainId»«IF handleEvents», «langExt.nullPointer», «langExt.nullPointer»«ENDIF»);
+									if («getHistory(state.genStateId)»==NO_STATE) {
+										state__et = executeTransitionChain(«langExt.selfPointer(true)»«chainIDScope»«sub_initt.genChainId»«IF handleEvents», «langExt.nullPointer», «langExt.nullPointer»«ENDIF»);
 									}
 									else {
-										state__et = «getHistory(state.getGenStateId())»;
+										state__et = «state.genStateId.history»;
 									}
 								«ELSE»
 									/* without init transition */
-									state__et = «getHistory(state.getGenStateId())»;
+									state__et = «state.genStateId.history»;
 								«ENDIF»
 								break;
 							«ENDIF»
@@ -383,8 +402,8 @@ abstract class AbstractStateMachineGenerator {
 
 		«IF generateImplementation»
 			«publicIf»void «opScope»executeInitTransition(«selfOnly») {
-				«var initt = xpmc.stateMachine.getInitTransition()»
-				int chain__et = «chainIDScope»«xpmc.getChain(initt).genChainId»;
+				«var initt = gc.graph.initialTransition»
+				int chain__et = «chainIDScope»«initt.genChainId»;
 				«stateType» next__et = «opScopePriv»executeTransitionChain(«langExt.selfPointer(true)»chain__et«IF handleEvents», «langExt.nullPointer», «langExt.nullPointer»«ENDIF»);
 				next__et = «opScopePriv»enterHistory(«langExt.selfPointer(true)»next__et«IF usesHdlr», «langExt.booleanConstant(false)»«ENDIF»);
 				setState(«langExt.selfPointer(true)»next__et);
@@ -412,10 +431,10 @@ abstract class AbstractStateMachineGenerator {
 
 				«IF handleEvents»
 					if (!handleSystemEvent(ifitem, evt, generic_data__et)) {
-						«genStateSwitch(xpmc, usesHdlr)»
+						«genStateSwitch(gc, usesHdlr)»
 					}
 				«ELSE»
-					«genStateSwitch(xpmc, usesHdlr)»
+					«genStateSwitch(gc, usesHdlr)»
 				«ENDIF»
 				if (chain__et != NOT_CAUGHT) {
 					«opScopePriv»exitTo(«langExt.selfPointer(true)»getState(«langExt.selfPointer(false)»), catching_state__et«IF usesHdlr», is_handler__et«ENDIF»);
@@ -423,7 +442,7 @@ abstract class AbstractStateMachineGenerator {
 						«stateType» next__et = «opScopePriv»executeTransitionChain(«langExt.selfPointer(true)»chain__et«IF handleEvents», ifitem, generic_data__et«ENDIF»);
 						next__et = «opScopePriv»enterHistory(«langExt.selfPointer(true)»next__et«IF usesHdlr», is_handler__et«ENDIF»);
 						setState(«langExt.selfPointer(true)»next__et);
-						«finalAction()»
+						«finalAction»
 					}
 				}
 			}
@@ -440,230 +459,233 @@ abstract class AbstractStateMachineGenerator {
 				void «opScope»receiveEvent(«langExt.selfPointer(true)»«ifItemPtr» ifitem, int evt, «langExt.voidPointer» generic_data__et);
 			«ENDIF»
 		«ENDIF»
-        '''
-    }
-
-    /**
-     * generate the do code calls for a given state
-     *
-     * @param state the {@link State}
-     * @return the generated code
-     */
-    def public String genDoCodes(State state) {'''
-        «IF state.hasDoCode(true)»
-            «state.getDoCodeOperationName()»(«langExt.selfPointer(false)»);
-        «ENDIF»
-        «IF state.eContainer.eContainer instanceof State»
-            «genDoCodes(state.eContainer.eContainer as State)»
-        «ENDIF»
-    '''}
-
-    /**
-     * helper method which generates the state switch.
-     * Asynchronous, data driven and event driven state machines are distinguished
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param usesHdlr if the state machine uses no handler {@link TransitionPoint}s
-     *      at all then unused variables can be avoided by passing <code>true</code>
-     * @return the generated code
-     */
-    def public genStateSwitch(ExpandedModelComponent xpmc, boolean usesHdlr) {
-        var async = xpmc.modelComponent.commType==ComponentCommunicationType::ASYNCHRONOUS
-        var eventDriven = xpmc.modelComponent.commType==ComponentCommunicationType::EVENT_DRIVEN
-        var dataDriven = xpmc.modelComponent.commType==ComponentCommunicationType::DATA_DRIVEN
-        '''
-            switch (getState(«langExt.selfPointer(false)»)) {
-                «FOR state : xpmc.stateMachine.getLeafStateList()»
-                case «state.getGenStateId()»:
-                    «IF async»
-                        «var atlist =  xpmc.getActiveTriggers(state)»
-                        «IF !atlist.isEmpty»
-                            switch(trigger__et) {
-                                case POLLING:
-                                    «genDataDrivenTriggers(xpmc, state, usesHdlr)»
-                                    break;
-                                «genEventDrivenTriggers(xpmc, state, atlist, usesHdlr)»
-                            }
-                        «ELSE»
-                                «genDataDrivenTriggers(xpmc, state, usesHdlr)»
-                        «ENDIF»
-                    «ELSEIF dataDriven»
-                            «genDataDrivenTriggers(xpmc, state, usesHdlr)»
-                    «ELSEIF eventDriven»
-                        «var atlist =  xpmc.getActiveTriggers(state)»
-                        «IF !atlist.isEmpty»
-                            switch(trigger__et) {
-                                    «genEventDrivenTriggers(xpmc, state, atlist, usesHdlr)»
-                            }
-                        «ENDIF»
-                    «ENDIF»
-                    break;
-                «ENDFOR»
-                default:
-                    /* should not occur */
-                    break;
-            }
-        '''
-    }
-
-    /**
-     * helper method which generates the data driven triggers
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param state the {@link State} for which the trigger if-else switch should be generated
-     * @param usesHdlr if the state machine uses no handler {@link TransitionPoints}
-     *      at all then unused variables can be avoided by passing <code>true</code>
-     * @return the generated code
-     */
-    def public genDataDrivenTriggers(ExpandedModelComponent xpmc, State state, boolean usesHdlr) {
-		val chainIDScope = if (langExt.usesInheritance) xpmc.className+langExt.scopeSeparator else ""
-        '''
-            «genDoCodes(state)»
-            «var transitions = xpmc.getOutgoingTransitionsHierarchical(state).filter(t|t instanceof GuardedTransition)»
-            «FOR tr : transitions»
-                if («guard((tr as GuardedTransition), "", xpmc)»)
-                {
-                    «var chain = xpmc.getChain(tr)»
-                    chain__et = «chainIDScope»«chain.genChainId»;
-                    catching_state__et = «chain.stateContext.genStateId»;
-                    «IF chain.isHandler() && usesHdlr»
-                        is_handler__et = TRUE;
-                    «ENDIF»
-                }
-                «IF tr!=transitions.last»
-                    else
-                «ENDIF»
-            «ENDFOR»
-        '''
-    }
-
-    /**
-     * helper method which generates the event driven triggers
-     *
-     * @param xpmc the {@link ExpandedModelComponent}
-     * @param state the {@link State} for which the trigger switch should be generated
-     * @param atlist the list of {@link ActiveTrigger}s of this state
-     * @param usesHdlr if the state machine uses no handler {@link TransitionPoints}
-     *      at all then unused variables can be avoided by passing <code>true</code>
-     * @return the generated code
-     */
-    def public genEventDrivenTriggers(ExpandedModelComponent xpmc, State state, List<ActiveTrigger> atlist, boolean usesHdlr) {
-		val chainIDScope = if (langExt.usesInheritance) xpmc.className+langExt.scopeSeparator else ""
-        '''
-            «FOR at : atlist»
-                case «xpmc.getTriggerCodeName(at)»:
-                    «var needData = at.hasGuard»
-                    «IF needData»{ «langExt.getTypedDataDefinition(at.msg)»«ENDIF»
-                    «FOR tt : at.transitions SEPARATOR " else "»
-                        «var chain = xpmc.getChain(tt)»
-                        «guard(chain.getTransition as TriggeredTransition, at.trigger, xpmc)»
-                        {
-                            chain__et = «chainIDScope»«chain.genChainId»;
-                            catching_state__et = «chain.stateContext.genStateId»;
-                            «IF chain.isHandler() && usesHdlr»
-                                is_handler__et = «langExt.booleanConstant(true)»;
-                            «ENDIF»
-                        }
-                    «ENDFOR»
-                    «IF needData»}«ENDIF»
-                break;
-            «ENDFOR»
-            default:
-                /* should not occur */
-                break;
-        '''
-    }
-
-    def public getClassName(ExpandedModelComponent xpmc) {
-        xpmc.modelComponent.className
-    }
-
-    def public getClassName(ModelComponent mc) {
-        mc.componentName
-    }
-
-    /**
-     * getter for history array
-     *
-     * @param state the ID of the history state
-     * @return the generated code
-     */
-    def public getHistory(String state) {
-        langExt.memberAccess+"history["+state+"]"
-    }
-
-    /**
-     * setter for history array
-     *
-     * @param state the ID of the state whose history should be set
-     * @param historyState the ID of the state that should be assigned
-     * @return the generated code
-     */
-    def public setHistory(String state, String historyState) {
-        langExt.memberAccess+"history["+state+"] = "+historyState
-    }
-
-    /**
-     * @return the type of (temporary) state variables (defaults to "int")
-     * and has to be signed
-     */
-    def public stateType() {
-        "int"
-    }
-
-    /**
-     * allow target language dependent generation of unreachable return in generated enterHistory method.
-     * The default is just a comment.
-     * @return the generated code
-     */
-    def public unreachableReturn() {
-        "/* return NO_STATE; // required by CDT but detected as unreachable by JDT because of while (true) */"
-    }
-
-    /**
-     * type of (temporary) boolean variables (defaults to "boolean")
-     * @return the generated code
-     */
-    def public boolType() {
-        return "boolean"
-    }
-
-    /**
-     * empty, but may be overridden
-     */
-    def public finalAction() {
-        ''''''
-    }
-
-    /**
-     * the type of the interface item passed into the receiveEvent() method
-     */
-    def public interfaceItemType() {
-        "InterfaceItemBase"
-    }
-
-    /**
-     * empty, but may be overridden
-     */
-    def markVariableUsed(String varname) {
-        ''''''
-    }
-
-    /**
-     * helper method to determine whether this state machine uses handler transitions
-     * points at all
-     *
-     * @param xpax the {@link ExpandedModelComponent}
-     * @return <code>true</code> if the state machine uses handler transition points
-     */
-    def public usesHandlerTrPoints(ExpandedModelComponent xpmc) {
-        if (xpmc.stateMachine.empty)
-            return false
-        !xpmc.stateMachine.allTrPointsRecursive.filter(t|t instanceof TransitionPoint && ((t as TransitionPoint).handler)).empty
-    }
-
-    def public String guard(TriggeredTransition tt, String trigger, ExpandedModelComponent mc)
-    def public String guard(GuardedTransition tt, String trigger, ExpandedModelComponent mc)
-    def public String genActionCodeMethod(ExpandedModelComponent xpmc, Transition tr, boolean generateImplementation)
-    def public String genActionCodeMethods(ExpandedModelComponent xpmc, State state, boolean generateImplementation)
+		'''
+	}
+
+	/**
+	 * generate the do code calls for a given state
+	 *
+	 * @param state the {@link State}
+	 * @return the generated code
+	 */
+	def public String genDoCodes(State state) {'''
+		«IF state.hasDoCode(true)»
+			«state.doCodeOperationName»(«langExt.selfPointer(false)»);
+		«ENDIF»
+		«IF state.eContainer.eContainer instanceof State»
+			«genDoCodes(state.eContainer.eContainer as State)»
+		«ENDIF»
+	'''}
+
+	/**
+	 * helper method which generates the state switch.
+	 * Asynchronous, data driven and event driven state machines are distinguished
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param usesHdlr if the state machine uses no handler {@link TransitionPoint}s
+	 *	  at all then unused variables can be avoided by passing <code>true</code>
+	 * @return the generated code
+	 */
+	def public genStateSwitch(GraphContainer gc, boolean usesHdlr) {
+		var async = gc.component.commType==ComponentCommunicationType::ASYNCHRONOUS
+		var eventDriven = gc.component.commType==ComponentCommunicationType::EVENT_DRIVEN
+		var dataDriven = gc.component.commType==ComponentCommunicationType::DATA_DRIVEN
+		val allLeafStateNodes = gc.graph.allStateNodes.filter[isLeaf].toList.sortBy[(stateGraphNode as State).genStateId]
+		'''
+			switch (getState(«langExt.selfPointer(false)»)) {
+				«FOR stateNode : allLeafStateNodes»
+					«val state = stateNode.stateGraphNode as State»
+					case «state.genStateId»:
+						«val caughtTriggers = stateNode.caughtTriggers»
+						«IF async»
+							«IF !caughtTriggers.isEmpty»
+								switch(trigger__et) {
+									case POLLING:
+										«genDataDrivenTriggers(gc, stateNode, usesHdlr)»
+										break;
+									«genEventDrivenTriggers(gc, stateNode, usesHdlr)»
+								}
+							«ELSE»
+								«genDataDrivenTriggers(gc, stateNode, usesHdlr)»
+							«ENDIF»
+						«ELSEIF dataDriven»
+								«genDataDrivenTriggers(gc, stateNode, usesHdlr)»
+						«ELSEIF eventDriven»
+							«IF !caughtTriggers.isEmpty»
+								switch(trigger__et) {
+									«genEventDrivenTriggers(gc, stateNode, usesHdlr)»
+								}
+							«ENDIF»
+						«ENDIF»
+						break;
+				«ENDFOR»
+				default:
+					/* should not occur */
+					break;
+			}
+		'''
+	}
+
+	/**
+	 * helper method which generates the data driven triggers
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param state the {@link State} for which the trigger if-else switch should be generated
+	 * @param usesHdlr if the state machine uses no handler {@link TransitionPoints}
+	 *	  at all then unused variables can be avoided by passing <code>true</code>
+	 * @return the generated code
+	 */
+	def public genDataDrivenTriggers(GraphContainer gc, Node stateNode, boolean usesHdlr) {
+		val chainIDScope = if (langExt.usesInheritance) gc.className+langExt.scopeSeparator else ""
+		val state = stateNode.stateGraphNode as State
+		'''
+			«genDoCodes(state)»
+			«var links = stateNode.getOutgoingLinksHierarchically.filter[transition instanceof GuardedTransition]»
+			«FOR l : links»
+				if («genGuardedTransitionGuard(l, "", gc)»)
+				{
+					chain__et = «chainIDScope»«l.transition.genChainId»;
+					catching_state__et = «l.transition.superState.genStateId»;
+					«IF l.isHandler && usesHdlr»
+						is_handler__et = TRUE;
+					«ENDIF»
+				}
+				«IF l!=links.last»
+					else
+				«ENDIF»
+			«ENDFOR»
+		'''
+	}
+
+	/**
+	 * helper method which generates the event driven triggers
+	 *
+	 * @param gc the {@link GraphContainer}
+	 * @param state the {@link State} for which the trigger switch should be generated
+	 * @param usesHdlr if the state machine uses no handler {@link TransitionPoints}
+	 *	  at all then unused variables can be avoided by passing <code>true</code>
+	 * @return the generated code
+	 */
+	def public genEventDrivenTriggers(GraphContainer gc, Node stateNode, boolean usesHdlr) {
+		val caughtTriggers = new ArrayList(stateNode.caughtTriggers).sortBy[triggerCodeName]
+		val chainIDScope = if (langExt.usesInheritance) gc.className+langExt.scopeSeparator else ""
+		'''
+			«FOR ct : caughtTriggers»
+				case «ct.triggerCodeName»:
+					«var needData = ct.hasGuard»
+					«IF needData»{ «langExt.getTypedDataDefinition(ct.msg)»«ENDIF»
+					«FOR link : ct.links SEPARATOR " else "»
+						«genTriggeredTransitionGuard(link, ct.trigger, gc)»
+						{
+							chain__et = «chainIDScope»«link.transition.genChainId»;
+							catching_state__et = «link.transition.superState.genStateId»;
+							«IF link.isHandler && usesHdlr»
+								is_handler__et = «langExt.booleanConstant(true)»;
+							«ENDIF»
+						}
+					«ENDFOR»
+					«IF needData»}«ENDIF»
+				break;
+			«ENDFOR»
+			default:
+				/* should not occur */
+				break;
+		'''
+	}
+
+	def public getClassName(GraphContainer gc) {
+		gc.component.className
+	}
+
+	def public getClassName(ModelComponent mc) {
+		mc.componentName
+	}
+
+	def getTriggerCodeName(CommonTrigger tr) {
+		val parts = tr.trigger.split(TriggerExtensions.TRIGGER_SEP)
+		return "TRIG_"+parts.get(0)+"__"+parts.get(1)
+	}
+	
+	/**
+	 * getter for history array
+	 *
+	 * @param state the ID of the history state
+	 * @return the generated code
+	 */
+	def public getHistory(String state) {
+		langExt.memberAccess+"history["+state+"]"
+	}
+
+	/**
+	 * setter for history array
+	 *
+	 * @param state the ID of the state whose history should be set
+	 * @param historyState the ID of the state that should be assigned
+	 * @return the generated code
+	 */
+	def public setHistory(String state, String historyState) {
+		langExt.memberAccess+"history["+state+"] = "+historyState
+	}
+
+	/**
+	 * @return the type of (temporary) state variables (defaults to "int")
+	 * and has to be signed
+	 */
+	def public stateType() {
+		"int"
+	}
+
+	/**
+	 * allow target language dependent generation of unreachable return in generated enterHistory method.
+	 * The default is just a comment.
+	 * @return the generated code
+	 */
+	def public unreachableReturn() {
+		"/* return NO_STATE; // required by CDT but detected as unreachable by JDT because of while (true) */"
+	}
+
+	/**
+	 * type of (temporary) boolean variables (defaults to "boolean")
+	 * @return the generated code
+	 */
+	def public boolType() {
+		return "boolean"
+	}
+
+	/**
+	 * empty, but may be overridden
+	 */
+	def public finalAction() {
+		''''''
+	}
+
+	/**
+	 * the type of the interface item passed into the receiveEvent() method
+	 */
+	def public interfaceItemType() {
+		"InterfaceItemBase"
+	}
+
+	/**
+	 * empty, but may be overridden
+	 */
+	def markVariableUsed(String varname) {
+		''''''
+	}
+
+	/**
+	 * helper method to determine whether this state machine uses handler transitions
+	 * points at all
+	 *
+	 * @param xpax the {@link GraphContainer}
+	 * @return <code>true</code> if the state machine uses handler transition points
+	 */
+	def public usesHandlerTrPoints(GraphContainer gc) {
+		!gc.graph.allTransitionPointNodes.filter(t|((t.stateGraphNode as TransitionPoint).handler)).empty
+	}
+
+	def public String genTriggeredTransitionGuard(Link link, String trigger, GraphContainer mc)
+	def public String genGuardedTransitionGuard(Link link, String trigger, GraphContainer mc)
+	def public String genActionCodeMethod(GraphContainer gc, Link link, boolean generateImplementation)
+	def public String genActionCodeMethods(GraphContainer gc, Node node, boolean generateImplementation)
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.xtend b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.xtend
index 0a88f76c5..e314b041e 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.xtend
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.xtend
@@ -12,19 +12,15 @@
 
 package org.eclipse.etrice.generator.fsm.generic
 
-import org.eclipse.etrice.core.fsm.fSM.Transition
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-import java.util.List
-import org.eclipse.etrice.core.fsm.fSM.State
-import java.util.ArrayList
-import org.eclipse.etrice.core.fsm.fSM.StateGraph
-import org.eclipse.etrice.core.fsm.fSM.TransitionPoint
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent
-import org.eclipse.etrice.core.fsm.util.FSMHelpers
 import com.google.inject.Inject
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition
 import org.eclipse.etrice.core.fsm.fSM.DetailCode
 import org.eclipse.etrice.core.fsm.fSM.Guard
-import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.util.FSMHelpers
 
 /**
  * @author Henrik Rentz-Reichert
@@ -75,36 +71,6 @@ class FSMExtensions {
 		return ret;
 	}
 
-    //-------------------------------------------------------
-    // state graph related methods
-
-	/**
-	 * @param ac an {@link ExpandedActorClass}
-	 * @param s a {@link State}
-	 * @return a list of {@link Transition}s starting at the state and going up in the hierarchy
-	 * 		following the logic of evaluation of firing conditions
-	 */
-	def List<Transition> getOutgoingTransitionsHierarchical(ExpandedModelComponent ac, State s) {
-		var result = new ArrayList<Transition>()
-		
-		// own transitions
-		result.addAll(ac.getOutgoingTransitions(s))
-
-		// transition points on same level
-		var sg = s.eContainer() as StateGraph
-		for (tp : sg.getTrPoints()) {
-			if (tp instanceof TransitionPoint)
-				result.addAll(ac.getOutgoingTransitions(tp))
-		}
-		
-		// recurse to super states
-		if (sg.eContainer() instanceof State) {
-			result.addAll(getOutgoingTransitionsHierarchical(ac, sg.eContainer() as State))
-		}
-		
-		return result;
-	}
-
     /**
      * @param states a list of {@link State}s
      * @return a list ordered such that leaf states are last
@@ -113,7 +79,7 @@ class FSMExtensions {
         val leaf = states.filter(s|s.leaf)
         val nonLeaf = states.filter(s|!s.leaf)
         
-        nonLeaf.union(leaf)
+        nonLeaf + leaf
     }
 
     /**
@@ -129,7 +95,7 @@ class FSMExtensions {
      * @return a list of simple states with leaf states last
      */
     def List<State> getAllBaseStatesLeavesLast(ModelComponent mc) {
-        mc.allBaseStates.getLeafStatesLast
+        mc.allBaseStates.getLeafStatesLast.toList
     }
 
     /**
@@ -137,7 +103,7 @@ class FSMExtensions {
      * @return the number of all inherited states
      */
     def int getNumberOfInheritedStates(ModelComponent mc) {
-        if (mc.base==null)
+        if (mc.base===null)
             return 0
         else
             return mc.base.stateMachine.stateList.size+mc.base.numberOfInheritedStates
@@ -148,7 +114,7 @@ class FSMExtensions {
      * @return the number of all inherited base (or simple) states
      */
     def int getNumberOfInheritedBaseStates(ModelComponent ac) {
-        if (ac.base==null)
+        if (ac.base===null)
             return 0
         else
             return ac.base.stateMachine.baseStateList.size+ac.base.numberOfInheritedBaseStates
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ILanguageExtensionBase.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ILanguageExtensionBase.java
index 2c2c3be69..bc46b0d50 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ILanguageExtensionBase.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ILanguageExtensionBase.java
@@ -194,10 +194,19 @@ public interface ILanguageExtensionBase {
 	String superCall(String baseClassName, String method, String arguments);
 
 	/**
+	 * the three results returned by {@link #org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase.generateArglistAndTypedData(EObject)}
+	 */
+	enum TypedDataKind {
+		COMMA_SEPARATED_PARAM_IN_CALL,
+		DECLARATION_AND_INITIALIZATION,
+		COMMA_SEPARATED_PARAM_IN_DECLARATION
+	}
+	
+	/**
 	 * return three strings used by the generator
 	 *
 	 * @param data the variable declaration
-	 * @return an array of three strings
+	 * @return an array of three strings (see {@link #TypedDataKind})
 	 * <ol>
 	 *  <li>the string that performs the cast from generic_data to the correct type and assigns it to a new variable</li>
 	 *  <li>the data as it appears in a method call</li>
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ITransitionChainVisitor.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ITransitionChainVisitor.java
index 1f3711c9b..2633814c8 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/fsmgen/ITransitionChainVisitor.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/ITransitionChainVisitor.java
@@ -10,12 +10,12 @@
  * 
  *******************************************************************************/
 
-package org.eclipse.etrice.core.genmodel.fsm.fsmgen;
+package org.eclipse.etrice.generator.fsm.generic;
 
 import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
 import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
 
 /**
  * This interface describes the transition chain visitor.
@@ -37,13 +37,13 @@ public interface ITransitionChainVisitor {
 	 * @param tc the transition chain
 	 * @return a typed declaration of the data associated with this message 
 	 */
-	String genTypedData(TransitionChain tc);
+	String genTypedData(TransitionBase tc);
 	
 	/**
 	 * @param tr a transition
 	 * @return a call of the action operation (as generated by the generator)
 	 */
-	String genActionOperationCall(Transition tr);
+	String genActionOperationCall(TransitionBase tr);
 	
 	/**
 	 * @param state a state
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainGenerator.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainGenerator.java
index 5d124b208..b5d94ea5b 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainGenerator.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainGenerator.java
@@ -12,13 +12,29 @@
 
 package org.eclipse.etrice.generator.fsm.generic;
 
-import org.eclipse.emf.ecore.EObject;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
+import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
+import org.eclipse.etrice.core.fsm.fSM.ExitPoint;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.fsm.fSM.TransitionPoint;
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
+import org.eclipse.etrice.core.fsm.util.FSMHelpers;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
 import org.eclipse.etrice.generator.fsm.base.CodegenHelpers;
+import org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase.TypedDataKind;
 
 import com.google.inject.Inject;
 
@@ -32,27 +48,125 @@ public class TransitionChainGenerator {
 	@Inject private ILanguageExtensionBase languageExt;
 	@Inject private CodegenHelpers codegenHelpers;
 	@Inject private IDetailCodeTranslator translator;
+	@Inject private FSMNameProvider fsmNameProvider;
+	@Inject private FSMHelpers fsmHelpers;
 
-	public String generateExecuteChain(ExpandedModelComponent xpmc, TransitionChain tc) {
-		TransitionChainVisitor tcv = new TransitionChainVisitor(xpmc, languageExt, codegenHelpers, translator);
-		tcv.init(tc);
+	public String generateExecuteChain(GraphContainer gc, Link l) {
+		TransitionChainVisitor tcv = new TransitionChainVisitor(gc, languageExt, codegenHelpers, translator);
+		tcv.init(l.getTransition());
 		
-		return tc.genExecuteChain(tcv);
+		return genExecuteChain(l, tcv);
 	}
 
-	public String generateArgumentList(ExpandedModelComponent xpmc, Transition t) {
-		if (t instanceof InitialTransition)
+	public String generateArgumentList(GraphContainer gc, Link l) {
+		if (l.getTransition() instanceof InitialTransition)
 			// actually is InitialTransition
 			return "";
 		
-		TransitionChain chain = xpmc.getChain(t);
-		if (!(chain.getTransition() instanceof TriggeredTransition))
+		if (!l.isIfitemTriggered())
 			return "";
 		
-		return generateTypedArgumentList(xpmc.getData(t));
+		return languageExt.generateArglistAndTypedData(l.getCommonData())[TypedDataKind.COMMA_SEPARATED_PARAM_IN_DECLARATION.ordinal()];
+	}
+
+	public String genExecuteChain(Link l, ITransitionChainVisitor tcv) {
+		StringBuilder result = new StringBuilder();
+		
+		/* TODO: the next generated code declares a correctly typed variable for the generic data.
+		 * It is hard to determine whether it is actually needed though.
+		 * It is needed in non-initial transitions with action code that are not data driven.
+		 * It might be needed in condition expressions. But this code would have to be parsed
+		 * with uncertain result (because of e.g. comments).
+		 */
+		result.append(tcv.genTypedData(l.getTransition()));
+		
+		genChainCode(l, tcv, result);
+		
+		return result.toString();
 	}
+	
+	private void genChainCode(Link l, ITransitionChainVisitor tcv, StringBuilder result) {
+		
+		result.append(tcv.genActionOperationCall(l.getTransition()));
+		
+		Node target = l.getTarget();
+		StateGraphNode stateGraphNode = target.getStateGraphNode();
+		List<Link> outgoing = new ArrayList<Link>(target.getOutgoing());
+		
+		// TODO: remove sorting again
+		final CodegenHelpers cgh = new CodegenHelpers();
+		Collections.sort(outgoing, new Comparator<Link>() {
+
+			@Override
+			public int compare(Link o1, Link o2) {
+				String id1 = cgh.getGenChainId(o1.getTransition());
+				String id2 = cgh.getGenChainId(o2.getTransition());
+				return id1.compareTo(id2);
+			}
+			
+		});
+		
+		if (stateGraphNode instanceof ChoicePoint) {
+			Link dflt = FsmGenExtensions.getChoicepointDefaultBranch(target);
+			assert(dflt!=null): "ChoicePoint "+fsmNameProvider.getFullPath(stateGraphNode)+" has no default branch!";
+			
+			// first generate all choicepoint branches as if/else
+			boolean isFirst = true;
+			for (Link cond : outgoing) {
+				if (cond==dflt)
+					continue;
+				
+				assert(cond.getTransition() instanceof CPBranchTransition): "The non default ChoicePoint branch "
+					+fsmNameProvider.getFullPath(cond.getTransition())+" must be of type CPBranchTransition!";
+				
+				result.append(tcv.genElseIfBranch((CPBranchTransition) cond.getTransition(), isFirst));
+				isFirst = false;
 
-	public String generateTypedArgumentList(EObject data) {
-		return languageExt.generateArglistAndTypedData(data)[2];
+				genChainCode(cond, tcv, result);
+			}
+			
+			// then generate the default branch
+			result.append(tcv.genElseBranch((ContinuationTransition) dflt.getTransition()));
+			
+			genChainCode(dflt, tcv, result);
+			
+			result.append(tcv.genEndIf());
+		}
+		else {
+			if (stateGraphNode instanceof TrPoint) {
+				if (stateGraphNode instanceof TransitionPoint) {
+					// TransitionPoint is final destination of the chain
+					result.append(tcv.genReturnState(fsmHelpers.getParentState(stateGraphNode), false));
+					return;
+				}	
+				else {
+					assert(outgoing.size()<=1): "TrPoint "+fsmNameProvider.getFullPath(stateGraphNode)
+								+" is expected to have at most one outgoing transition!";
+					if (outgoing.size()==1) {
+						State state = fsmHelpers.getParentState(stateGraphNode);
+						if (stateGraphNode instanceof EntryPoint) {
+							if (state!=null && !target.isInherited() && fsmHelpers.hasEntryCode(state, true))
+								result.append(tcv.genEntryOperationCall(state));
+						}
+						else if (stateGraphNode instanceof ExitPoint) {
+							if (state!=null && !target.isInherited() && fsmHelpers.hasExitCode(state, true))
+								result.append(tcv.genExitOperationCall(state));
+						}
+						else {
+							assert(false): "unexpected sub type";
+						}
+					}
+				}
+				if (! outgoing.isEmpty()) {
+					genChainCode(outgoing.get(0), tcv, result);
+				}
+			}
+			else {
+				// the following assertion should always hold true
+				assert(stateGraphNode instanceof State): "A transition target can be a ChoicePoint, a TrPoint or a State!";
+				
+				result.append(tcv.genReturnState((State) stateGraphNode, true));
+			}
+		}
 	}
 }
diff --git a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainVisitor.java b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainVisitor.java
index 1354d593d..2e4a17115 100644
--- a/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainVisitor.java
+++ b/plugins/org.eclipse.etrice.generator.fsm/src/org/eclipse/etrice/generator/fsm/generic/TransitionChainVisitor.java
@@ -16,13 +16,15 @@ import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
 import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
 import org.eclipse.etrice.core.fsm.fSM.GuardedTransition;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
 import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
 import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ITransitionChainVisitor;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
 import org.eclipse.etrice.generator.fsm.base.CodegenHelpers;
+import org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase.TypedDataKind;
 
 /**
  * Implementation of the {@link org.eclipse.etrice.core.genmodel.fsm.fsmgen.ITransitionChainVisitor ITransitionChainVisitor} interface.
@@ -36,12 +38,11 @@ public class TransitionChainVisitor implements ITransitionChainVisitor {
 	private FSMHelpers fsmHelpers = new FSMHelpers();
 	
 	// Initialized in constructor
-	private ExpandedModelComponent xpac;
+	private GraphContainer gc;
 	private ILanguageExtensionBase langExt;
 	private CodegenHelpers codegenHelpers;
 	private IDetailCodeTranslator translationProvider;
 	
-	private TransitionChain tc = null;
 	private boolean dataDriven = false;
 
 	/**
@@ -52,42 +53,45 @@ public class TransitionChainVisitor implements ITransitionChainVisitor {
 	 * @param languageExt 
 	 */
 	protected TransitionChainVisitor(
-			ExpandedModelComponent xpac,
+			GraphContainer gc,
 			ILanguageExtensionBase languageExt,
 			CodegenHelpers codegenHelpers,
 			IDetailCodeTranslator translationProvider
 	) {
-		this.xpac = xpac;
+		this.gc = gc;
 		this.langExt = languageExt;
 		this.codegenHelpers = codegenHelpers;
 		this.translationProvider = translationProvider;
 	}
 	
-	protected void init(TransitionChain tc) {
-		this.tc = tc;
-		
-		if (tc.getTransition() instanceof GuardedTransition) {
+	protected void init(TransitionBase tr) {
+		while (tr instanceof RefinedTransition) {
+			tr = ((RefinedTransition) tr).getTarget();
+		}
+		if (tr instanceof GuardedTransition) {
 			dataDriven = true;
 		}
-		else if (tc.getTransition() instanceof InitialTransition) {
+		else if (tr instanceof InitialTransition) {
 			dataDriven = true;
 		}
 	}
 
 	// ITransitionChainVisitor interface
 	
-	public String genActionOperationCall(Transition tr) {
+	public String genActionOperationCall(TransitionBase tr) {
 		boolean noIfItem = dataDriven;
-		for(TransitionChain tc : xpac.getChains(tr))
-			noIfItem |= tc.getTransition() instanceof InitialTransition;
+		Link l = FsmGenExtensions.getLinkFor(gc, tr);
+		for (Link ch : l.getChainHeads()) {
+			noIfItem |= ch.getTransition() instanceof InitialTransition;
+		}
 		
 		if (fsmHelpers.hasDetailCode(tr.getAction())) {
 			if (noIfItem)
 				return codegenHelpers.getActionCodeOperationName(tr)+"("+langExt.selfPointer(false)+");\n";
 			else {
 				String dataArg = "";
-				if(xpac.getData(tr) != null)
-					dataArg = langExt.generateArglistAndTypedData(tc.getData())[0];
+				if (l.getCommonData() != null)
+					dataArg = langExt.generateArglistAndTypedData(l.getCommonData())[TypedDataKind.COMMA_SEPARATED_PARAM_IN_CALL.ordinal()];
 				return codegenHelpers.getActionCodeOperationName(tr)+"("+langExt.selfPointer(true)+"ifitem"+dataArg+");\n";
 			}
 		}
@@ -129,9 +133,9 @@ public class TransitionChainVisitor implements ITransitionChainVisitor {
 			return "return " + codegenHelpers.getGenStateId(state) + " + STATE_MAX;";
 	}
 
-	public String genTypedData(TransitionChain tc) {
-		String[] result = langExt.generateArglistAndTypedData(tc.getData());
-		return result[1];
+	public String genTypedData(TransitionBase tr) {
+		Link l = FsmGenExtensions.getLinkFor(gc, tr);
+		return langExt.generateArglistAndTypedData(l.getCommonData())[TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal()];
 	}
 
 }
diff --git a/plugins/org.eclipse.etrice.generator.java/.classpath b/plugins/org.eclipse.etrice.generator.java/.classpath
index 13a6c6528..87e8cd659 100644
--- a/plugins/org.eclipse.etrice.generator.java/.classpath
+++ b/plugins/org.eclipse.etrice.generator.java/.classpath
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="src" path="xtend-gen"/>
+	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.etrice.generator.java/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.generator.java/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.xtend
index 6e248ab2f..6d045f7f9 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.xtend
@@ -51,7 +51,7 @@ class ActorClassDataGen {
 		val ac = xpac.actorClass
 		val clsname = ac.name+"_DataObject"
 		val models = root.getReferencedModels(ac)
-		val baseClass = if (ac.base!=null) "extends "+ac.actorBase.name+"_DataObject " else ""
+		val baseClass = if (ac.base!==null) "extends "+ac.actorBase.name+"_DataObject " else ""
 		
 	'''
 		package «ac.getPackage»;
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassGen.xtend
index d573ba315..4bef3f8b3 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassGen.xtend
@@ -32,6 +32,8 @@ import org.eclipse.etrice.generator.generic.ProcedureHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.etrice.generator.generic.TypeHelpers
 import org.eclipse.etrice.generator.java.Main
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+import org.eclipse.etrice.generator.generic.ILanguageExtension
 
 @Singleton
 class ActorClassGen extends GenericActorClassGenerator {
@@ -74,7 +76,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 		val models = root.getReferencedModels(ac)
 		val impPersist = if (Main::settings.generatePersistenceInterface) "implements IPersistable " else ""
 		val dataObjClass = ac.name+"_DataObject"
-		val baseClass = if (ac.actorBase!=null) ac.actorBase.name
+		val baseClass = if (ac.actorBase!==null) ac.actorBase.name
 			else if (!ac.getAttribute("ActorBaseClass", "class").empty) ac.getAttribute("ActorBaseClass", "class")
 			else if (Main::settings.generateStoreDataObj) "ActorClassFinalActionBase"
 			else "ActorClassBase"
@@ -257,12 +259,12 @@ class ActorClassGen extends GenericActorClassGenerator {
 							switch (evt) {
 								«FOR msg: ifitem.incoming»
 									case «msg.protocolClass.name».«if (msg.incoming) "IN_" else "OUT_"»«msg.name»:
-										«IF (msg.data!=null)»
+										«IF (msg.data!==null)»
 											{«msg.typedDataDefinition»
 										«ENDIF»
-										on_«ifitem.name»_«msg.name»(ifitem«IF (msg.data!=null)», «msg.data.name»«ENDIF»);
+										on_«ifitem.name»_«msg.name»(ifitem«IF (msg.data!==null)», «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»);
 										break;
-										«IF (msg.data!=null)»
+										«IF (msg.data!==null)»
 											}
 										«ENDIF»
 								«ENDFOR»
@@ -272,14 +274,14 @@ class ActorClassGen extends GenericActorClassGenerator {
 				}
 				«FOR ifitem : ac.allInterfaceItems»
 					«FOR msg: ifitem.incoming»
-						protected void on_«ifitem.name»_«msg.name»(InterfaceItemBase ifitem«IF msg.data!=null»«msg.data.generateArglistAndTypedData.get(2)»«ENDIF») {}
+						protected void on_«ifitem.name»_«msg.name»(InterfaceItemBase ifitem«IF msg.data!==null»«msg.data.generateArglistAndTypedData.get(2)»«ENDIF») {}
 					«ENDFOR»
 				«ENDFOR»
 
 				public abstract void executeInitTransition();
 			«ELSE»
 				«IF ac.hasNonEmptyStateMachine»
-					«xpac.genStateMachine()»
+					«xpac.graphContainer.genStateMachine»
 					«IF ac.commType == ComponentCommunicationType::DATA_DRIVEN»
 						public void receiveEvent(InterfaceItemBase ifitem, int evt, Object generic_data) {
 							handleSystemEvent(ifitem, evt, generic_data);
@@ -295,7 +297,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 							«ENDIF»
 						}
 					«ENDIF»
-				«ELSEIF xpac.stateMachine.empty»
+				«ELSEIF xpac.graphContainer.graph.empty»
 «««					no state machine in the super classes
 					//--------------------- no state machine
 					public void receiveEvent(InterfaceItemBase ifitem, int evt, Object data) {
@@ -310,7 +312,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 
 				@Override
 				public void saveObject(ObjectOutput output) throws IOException {
-					«IF xpac.hasStateMachine()»
+					«IF !xpac.graphContainer.graph.empty»
 						// state and history
 						output.writeInt(getState());
 						for (int h: history) output.writeInt(h);
@@ -325,7 +327,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 
 				@Override
 				public void loadObject(ObjectInput input) throws IOException, ClassNotFoundException {
-					«IF xpac.hasStateMachine()»
+					«IF !xpac.graphContainer.graph.empty»
 						// state and history
 						setState(input.readInt());
 						for (int i=0; i<history.length; ++i) history[i] = input.readInt();
@@ -345,7 +347,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 						return;
 
 					«dataObjClass» dataObject = («dataObjClass») obj;
-					«IF ac.actorBase!=null»
+					«IF ac.actorBase!==null»
 
 						super.store(dataObject);
 					«ENDIF»
@@ -384,7 +386,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 						return;
 
 					«dataObjClass» dataObject = («dataObjClass») obj;
-					«IF ac.actorBase!=null»
+					«IF ac.actorBase!==null»
 
 						super.restore(dataObject);
 					«ENDIF»
@@ -429,7 +431,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 	private def genSaveImpl(ExpandedActorClass xpac) {
 		val ac = xpac.actorClass
 		'''
-			«IF ac.actorBase!=null»
+			«IF ac.actorBase!==null»
 				super.saveAttributes(output);
 
 			«ENDIF»
@@ -453,7 +455,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 	private def genLoadImpl(ExpandedActorClass xpac) {
 		val ac = xpac.actorClass
 		'''
-			«IF ac.actorBase!=null»
+			«IF ac.actorBase!==null»
 				super.loadAttributes(input);
 
 			«ENDIF»
@@ -475,7 +477,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 	}
 
 	private def genSavePrimitive(Attribute att) {
-		val type = if (att.type.type instanceof EnumerationType && (att.type.type as EnumerationType).primitiveType==null)
+		val type = if (att.type.type instanceof EnumerationType && (att.type.type as EnumerationType).primitiveType===null)
 			"int"
 		else
 			att.type.type.typeName
@@ -502,7 +504,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 	}
 
 	private def genLoadPrimitive(Attribute att) {
-		val type = if (att.type.type instanceof EnumerationType && (att.type.type as EnumerationType).primitiveType==null)
+		val type = if (att.type.type instanceof EnumerationType && (att.type.type as EnumerationType).primitiveType===null)
 			"int"
 		else
 			att.type.type.typeName
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.xtend
index 2dc1894dc..bb25bc481 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.xtend
@@ -46,7 +46,7 @@ class ConfigGenAddon {
 			«ENDFOR»
 			«FOR pi : ai.orderedIfItemInstances»
 				«var attribs = getPortClass(pi.interfaceItem)?.attributes»
-				«IF attribs != null»
+				«IF attribs !== null»
 					«FOR a : attribs»
 						«applyInstanceConfig(pi, aiVariableName+"."+invokeGetter(pi.name, null), new ArrayList<Attribute>().union(a))»
 					«ENDFOR»
@@ -61,12 +61,12 @@ class ConfigGenAddon {
 		switch aType {
 			PrimitiveType: {
 				var value = typeHelpers.getAttrInstanceConfigValue(path, instance)
-				if(value != null)
+				if(value !== null)
 					initGen.genAttributeInitializer(a, toValueLiteral(aType, value), invokes)	
 			}
 			EnumerationType: {
 				var value = typeHelpers.getAttrInstanceConfigValue(path, instance)
-				if(value != null)
+				if(value !== null)
 					initGen.genAttributeInitializer(a, value, invokes)
 			}
 			DataClass:
@@ -133,10 +133,10 @@ class ConfigGenAddon {
 			PrimitiveType:{
 				var temp = null as String
 				'''
-					«IF (temp = dataConfigExt.getAttrClassConfigMinValue(ac, path)) != null»
+					«IF (temp = dataConfigExt.getAttrClassConfigMinValue(ac, path)) !== null»
 						public static «aType.minMaxType» MIN_«varNamePath» = «aType.toValueLiteral(temp)»;
 					«ENDIF»
-					«IF (temp = dataConfigExt.getAttrClassConfigMaxValue(ac, path)) != null»
+					«IF (temp = dataConfigExt.getAttrClassConfigMaxValue(ac, path)) !== null»
 						public static «aType.minMaxType» MAX_«varNamePath» = «aType.toValueLiteral(temp)»;
 					«ENDIF»
 				'''
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/DataClassGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/DataClassGen.xtend
index 6f10d38d0..a4530f774 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/DataClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/DataClassGen.xtend
@@ -60,7 +60,7 @@ class DataClassGen {
 		«dc.userCode(1)»
 
 
-		public class «dc.name»«IF dc.base!=null» extends «dc.base.name»«ENDIF» implements Serializable {
+		public class «dc.name»«IF dc.base!==null» extends «dc.base.name»«ENDIF» implements Serializable {
 
 			private static final long serialVersionUID = «(dc.package+dc.name).hashCode»L;
 
@@ -83,7 +83,7 @@ class DataClassGen {
 
 			// constructor using fields
 			public «dc.name»(«dc.argList») {
-				«IF dc.base!=null»
+				«IF dc.base!==null»
 				super(«dc.base.paramList»);
 				«ELSE»
 				super();
@@ -109,10 +109,10 @@ class DataClassGen {
 	def paramList(DataClass _dc) {
 		var result = ""
 		var dc = _dc
-		while (dc!=null) {
+		while (dc!==null) {
 			result = dc.attributes.paramList.toString + result
 			dc = dc.base
-			if (dc!=null)
+			if (dc!==null)
 				result = ", "+result
 		}
 		return result
@@ -129,7 +129,7 @@ class DataClassGen {
 	def private deepCopy(DataClass _dc) {
 		var result = ""
 		var dc = _dc
-		while (dc!=null) {
+		while (dc!==null) {
 			result = deepCopy(dc.attributes).toString + result
 			dc = dc.base
 		}
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Initialization.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Initialization.xtend
index f1506768c..302dd5929 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Initialization.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Initialization.xtend
@@ -51,20 +51,20 @@ class Initialization {
 
 		switch (aType) {
 			case (a.type.ref):
-				if (a.defaultValueLiteral != null)
+				if (a.defaultValueLiteral !== null)
 					attributeInit(a, a.defaultValueLiteral)
 				else if (languageExt.needsInitialization(a))
 					attributeInit(a, languageExt.nullPointer)
 			PrimitiveType: {
 				var value = getDataConfigValue(new ArrayList<Attribute>.union(a), roomClass)
-				if(value == null) value = a.defaultValueLiteral
-				if(value != null) attributeInit(a, languageExt.toValueLiteral(aType, value)) else if(!useClassDefaultsOnly ||
+				if(value === null) value = a.defaultValueLiteral
+				if(value !== null) attributeInit(a, languageExt.toValueLiteral(aType, value)) else if(!useClassDefaultsOnly ||
 					languageExt.needsInitialization(a)) attributeInit(a, languageExt.defaultValue(aType))
 			}
 			EnumerationType: {
 				var value = getDataConfigValue(new ArrayList<Attribute>.union(a), roomClass)
-				if(value == null) value = a.defaultValueLiteral
-				if(value != null) attributeInit(a, languageExt.toEnumLiteral(aType, value)) else if(!useClassDefaultsOnly ||
+				if(value === null) value = a.defaultValueLiteral
+				if(value !== null) attributeInit(a, languageExt.toEnumLiteral(aType, value)) else if(!useClassDefaultsOnly ||
 					languageExt.needsInitialization(a)) attributeInit(a, languageExt.defaultValue(aType))
 			}
 			default:
@@ -85,11 +85,11 @@ class Initialization {
 				'''
 			PrimitiveType: {
 				var value = getDataConfigValue(path, roomClass)
-				return if(value != null) attributeInit(path, languageExt.toValueLiteral(aType, value))
+				return if(value !== null) attributeInit(path, languageExt.toValueLiteral(aType, value))
 			}
 			EnumerationType: {
 				var value = getDataConfigValue(path, roomClass)
-				return if(value != null) attributeInit(path, languageExt.toEnumLiteral(aType, value))
+				return if(value !== null) attributeInit(path, languageExt.toEnumLiteral(aType, value))
 			}
 		}
 	}
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaExtensions.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaExtensions.xtend
index 440c3e8d0..6cb8cf0eb 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaExtensions.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaExtensions.xtend
@@ -20,32 +20,31 @@ package org.eclipse.etrice.generator.java.gen
 import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef
+import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
+import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.Attribute
 import org.eclipse.etrice.core.room.DataType
+import org.eclipse.etrice.core.room.EnumLiteral
+import org.eclipse.etrice.core.room.EnumerationType
 import org.eclipse.etrice.core.room.ExternalType
 import org.eclipse.etrice.core.room.Message
+import org.eclipse.etrice.core.room.MessageData
 import org.eclipse.etrice.core.room.PrimitiveType
 import org.eclipse.etrice.core.room.RoomClass
-import org.eclipse.etrice.core.room.VarDecl
 import org.eclipse.etrice.generator.generic.ILanguageExtension
 import org.eclipse.etrice.generator.generic.TypeHelpers
 import org.eclipse.xtext.util.Pair
-import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance
-import org.eclipse.etrice.core.etphys.eTPhys.NodeRef
-import org.eclipse.etrice.core.room.ActorClass
-import org.eclipse.etrice.core.room.EnumerationType
-
-import org.eclipse.etrice.core.room.EnumLiteral
-import org.eclipse.emf.ecore.EObject
 
 @Singleton
 class JavaExtensions implements ILanguageExtension {
-
+	
 	@Inject TypeHelpers typeHelpers
 
 	override String getTypedDataDefinition(EObject msg) {
 	    if (msg instanceof Message) {
-    		generateArglistAndTypedData((msg as Message).data).get(1)
+    		generateArglistAndTypedData((msg as Message).data).get(TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal)
 	    }
 	    else {
 	        ""
@@ -171,7 +170,7 @@ class JavaExtensions implements ILanguageExtension {
 			v = v.substring(type.name.length+1)
 		for(EnumLiteral l : type.literals)
 			if(l.name.equals(v))
-				return type.getName()+"."+l.getName()
+				return type.name+"."+l.name
 	}
 
 	def private castValue(PrimitiveType type, String value){
@@ -209,7 +208,7 @@ class JavaExtensions implements ILanguageExtension {
 			PrimitiveType:
 				toValueLiteral(dt, dt.defaultValueLiteral)
 			EnumerationType:
-				getDefaultValue(dt)
+				dt.defaultValue
 			ExternalType:
 				"new "+(dt as ExternalType).targetName+"()"
 			default:
@@ -242,16 +241,17 @@ class JavaExtensions implements ILanguageExtension {
 	}
 
 	override generateArglistAndTypedData(EObject d) {
-		if (d==null || !(d instanceof VarDecl))
+		// TODO 529445: d will be a RefableType, not MessageData
+		if (d===null || !(d instanceof MessageData))
 			return newArrayList("", "", "")
 
-		val data = d as VarDecl
-		var typeName = data.refType.type.getName();
-		var castTypeName = typeName;
+		val data = d as MessageData
+		var typeName = data.refType.type.name
+		var castTypeName = typeName
 		if (data.refType.type instanceof PrimitiveType) {
-			typeName = (data.refType.type as PrimitiveType).getTargetName()
-			val ct = (data.refType.type as PrimitiveType).getCastName()
-			if (ct!=null && !ct.isEmpty())
+			typeName = (data.refType.type as PrimitiveType).targetName
+			val ct = (data.refType.type as PrimitiveType).castName
+			if (ct!==null && !ct.isEmpty())
 				castTypeName = ct
 		}
 		else if (data.refType.type instanceof EnumerationType) {
@@ -259,16 +259,16 @@ class JavaExtensions implements ILanguageExtension {
 			castTypeName = (data.refType.type as EnumerationType).castType
 		}
 
-		val typedData = typeName+" "+data.getName() + " = ("+castTypeName+") generic_data__et;\n";
-		val dataArg = ", "+data.getName();
-		val typedArgList = ", "+typeName+" "+data.getName();
+		val dataArg = ", " + GENERIC_DATA_NAME
+		val typedData = typeName + " " + GENERIC_DATA_NAME + " = ("+castTypeName+") generic_data__et;\n"
+		val typedArgList = ", " + typeName + " " + GENERIC_DATA_NAME
 
-		return newArrayList(dataArg, typedData, typedArgList);
+		return newArrayList(dataArg, typedData, typedArgList)
 	}
 
 	override getTargetType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
-			type.getPrimitiveType().getTargetName()
+		if (type.primitiveType!==null)
+			type.primitiveType.targetName
 		else
 			"int"
 	}
@@ -277,15 +277,15 @@ class JavaExtensions implements ILanguageExtension {
 		val type = literal.eContainer() as EnumerationType
 		val cast = type.targetType
 
-		if (type.primitiveType==null)
-			Long.toString(literal.getLiteralValue())
+		if (type.primitiveType===null)
+			Long.toString(literal.literalValue)
 		else
-			"(("+cast+")"+Long.toString(literal.getLiteralValue())+")"
+			"(("+cast+")"+Long.toString(literal.literalValue)+")"
 	}
 
 	override getCastType(EnumerationType type) {
-		if (type.getPrimitiveType()!=null)
-			type.getPrimitiveType().getCastName()
+		if (type.primitiveType!==null)
+			type.primitiveType.castName
 		else
 			"int"
 	}
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaTranslationProvider.java b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaTranslationProvider.java
index cdfdfc660..e7591cf59 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/JavaTranslationProvider.java
@@ -12,12 +12,12 @@
 
 package org.eclipse.etrice.generator.java.gen;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.room.Attribute;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.DetailCode;
+import org.eclipse.etrice.core.room.Attribute;
 import org.eclipse.etrice.core.room.InterfaceItem;
 import org.eclipse.etrice.core.room.Message;
 import org.eclipse.etrice.generator.base.DefaultTranslationProvider;
@@ -47,7 +47,7 @@ public class JavaTranslationProvider extends DefaultTranslationProvider {
 	}
 	
 	@Override
-	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, ArrayList<String> args, String index, String orig) {
+	public String getInterfaceItemMessageText(AbstractInterfaceItem item, EObject abstractMsg, List<String> args, String index, String orig) {
 		if (index==null)
 			return orig;
 
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeGen.xtend
index 793c38e3e..e77e89409 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeGen.xtend
@@ -22,7 +22,6 @@ import org.eclipse.etrice.core.etphys.eTPhys.ExecMode
 import org.eclipse.etrice.core.etphys.eTPhys.PhysicalThread
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInterfaceInstance
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician
 import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase
 import org.eclipse.etrice.core.genmodel.etricegen.Root
 import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance
@@ -43,6 +42,7 @@ import static extension org.eclipse.etrice.generator.fsm.base.Indexed.*
 import com.google.common.collect.Lists
 import com.google.common.collect.Sets
 import org.eclipse.etrice.core.genmodel.builder.GenmodelConstants
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician
 
 @Singleton
 class NodeGen {
@@ -64,7 +64,7 @@ class NodeGen {
 		for (nr : ETMapUtil::getNodeRefs()) {
 			for (instpath : ETMapUtil::getSubSystemInstancePaths(nr)) {
 				val ssi = root.getInstance(instpath) as SubSystemInstance
-				if (ssi!=null && ssi.subSystemClass.validGenerationLocation) {
+				if (ssi!==null && ssi.subSystemClass.validGenerationLocation) {
 					val wired = sscc2wired.get(ssi.subSystemClass)
 					val path = ssi.subSystemClass.generationTargetPath+ssi.subSystemClass.getPath
 					val infopath = ssi.subSystemClass.generationInfoPath+ssi.subSystemClass.getPath
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeRunnerGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeRunnerGen.xtend
index 336b5523b..987c01008 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeRunnerGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeRunnerGen.xtend
@@ -35,7 +35,7 @@ class NodeRunnerGen {
 		for (nr : ETMapUtil::getNodeRefs()) {
 			for (instpath : ETMapUtil::getSubSystemInstancePaths(nr)) {
 				val ssi = root.getInstance(instpath) as SubSystemInstance
-				if (ssi!=null && ssi.subSystemClass.validGenerationLocation) {
+				if (ssi!==null && ssi.subSystemClass.validGenerationLocation) {
 					val file = nr.getJavaClassName(ssi)+"Runner.java"
 					val filepath = ssi.subSystemClass.generationTargetPath+ssi.subSystemClass.getPath
 					val infopath = ssi.subSystemClass.generationInfoPath+ssi.subSystemClass.getPath
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.xtend
index 9bb517b43..369d92c64 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.xtend
@@ -14,7 +14,6 @@ package org.eclipse.etrice.generator.java.gen
 
 import com.google.inject.Inject
 import com.google.inject.Singleton
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
 import org.eclipse.etrice.core.genmodel.etricegen.Root
 import org.eclipse.etrice.core.room.CommunicationType
 import org.eclipse.etrice.core.room.DataClass
@@ -27,6 +26,8 @@ import org.eclipse.etrice.generator.generic.ProcedureHelpers
 import org.eclipse.etrice.generator.generic.RoomExtensions
 import org.eclipse.etrice.generator.generic.TypeHelpers
 import org.eclipse.etrice.generator.java.Main
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
+import org.eclipse.etrice.generator.generic.ILanguageExtension
 
 @Singleton
 class ProtocolClassGen extends GenericProtocolClassGenerator {
@@ -116,7 +117,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 
 		// port class
 		static public class «portClassName» extends PortBase {
-			«IF pclass!=null»
+			«IF pclass!==null»
 				«pclass.userCode.userCode»
 			«ENDIF»
 			// constructors
@@ -125,7 +126,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 			}
 			public «portClassName»(IInterfaceItemOwner actor, String name, int localId, int idx) {
 				super(actor, name, localId, idx);
-				«IF pclass!=null»
+				«IF pclass!==null»
 					«pclass.attributes.attributeInitialization(pclass, true)»
 				«ENDIF»
 				«IF Main::settings.generateMSCInstrumentation»
@@ -172,7 +173,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 				}
 		}
 
-			«IF pclass!=null»
+			«IF pclass!==null»
 				«pclass.attributes.attributes»
 «««				// TODO JH: Avoid collision attr getters/setter <-> user operations
 				«attributeSettersGettersImplementation(pclass.attributes, null)»
@@ -245,7 +246,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	}
 
 	def messageSignature(Message m) {
-		'''«IF m.priv»private«ELSE»public«ENDIF» void «m.name»(«IF m.data!=null»«m.data.refType.type.typeName» «m.data.name»«ENDIF»)'''
+		'''«IF m.priv»private«ELSE»public«ENDIF» void «m.name»(«IF m.data!==null»«m.data.refType.type.typeName» «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»)'''
 	}
 
 	def messageSignatureExplicit(Message m) {
@@ -254,7 +255,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	}
 
 	def messageCall(Message m) {
-		'''«m.name»(«IF m.data!=null» «m.data.name»«ENDIF»)'''
+		'''«m.name»(«IF m.data!==null» «ILanguageExtension.GENERIC_DATA_NAME»«ENDIF»)'''
 	}
 
 	def sendMessage(Message m, boolean conj) {
@@ -262,7 +263,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 		var hdlr = m.getSendHandler(conj)
 		'''
 			«messageSignature(m)» {
-				«IF hdlr!=null»
+				«IF hdlr!==null»
 					«FOR command : hdlr.detailCode.lines»	«command»
 					«ENDFOR»
 				«ELSE»
@@ -270,14 +271,14 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 						DebuggingService.getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(), messageStrings[«dir»_«m.name»]);
 					«ENDIF»
 					if (getPeerAddress()!=null)
-						«IF m.data==null»
+						«IF m.data===null»
 							getPeerMsgReceiver().receive(new EventMessage(getPeerAddress(), «dir»_«m.name»));
 						«ELSE»
-							getPeerMsgReceiver().receive(new EventWithDataMessage(getPeerAddress(), «dir»_«m.name», «m.data.name»«IF (!m.data.refType.ref && !(m.data.refType.type.enumerationOrPrimitive))».deepCopy()«ENDIF»));
+							getPeerMsgReceiver().receive(new EventWithDataMessage(getPeerAddress(), «dir»_«m.name», «ILanguageExtension.GENERIC_DATA_NAME»«IF (!m.data.refType.ref && !(m.data.refType.type.enumerationOrPrimitive))».deepCopy()«ENDIF»));
 						«ENDIF»
 				«ENDIF»
 			}
-			«IF m.data!=null && m.data.refType.type instanceof DataClass»
+			«IF m.data!==null && m.data.refType.type instanceof DataClass»
 				«messageSignatureExplicit(m)» {
 					«m.name»(new «m.data.refType.type.name»(«(m.data.refType.type as DataClass).paramList»));
 				}
@@ -286,7 +287,7 @@ class ProtocolClassGen extends GenericProtocolClassGenerator {
 	}
 
 	def generateDataDriven(Root root, ProtocolClass pc) {
-		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!=null)
+		val sentMsgs = pc.allIncomingMessages.filter(m|m.data!==null)
 		val models = root.getReferencedModels(pc)
 		'''
 			package «pc.getPackage()»;
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/StateMachineGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/StateMachineGen.xtend
index f2e971d2c..b2910ad5a 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/StateMachineGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/StateMachineGen.xtend
@@ -13,37 +13,35 @@
 package org.eclipse.etrice.generator.java.gen
 
 import com.google.inject.Singleton
-import java.util.ArrayList
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass
+import java.util.Comparator
 import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
 import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator
 import org.eclipse.etrice.generator.java.Main
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
 
 @Singleton
 class StateMachineGen extends GenericStateMachineGenerator {
 
+	val nodeComparator = new NodeComparator
+
 	/**
 	 * @param generateImplementation NOT used
 	 */
-	override genExtra(ExpandedModelComponent xpac, boolean generateImplementation) {
-		val states = new ArrayList<State>()
-		var ac = xpac.modelComponent
+	override genExtra(GraphContainer gc, boolean generateImplementation) {
+		val orderedStateNodes = gc.graph.allStateNodes.toList.sortWith(nodeComparator)
 
-//		it is crucial that we obey the order that is used for state IDs
-//		that means we have to collect base classes first and each base class list with leaf states last
-		while (ac!=null) {
-			states.addAll(0, ac.allBaseStates.leafStatesLast)
-			ac = ac.base
-		}
 	'''
 		«IF Main::settings.generateMSCInstrumentation || Main::settings.generateWithVerboseOutput»
 			// state names
 			protected static final String stateStrings[] = {
 				"<no state>",
 				"<top>",
-				«FOR state : states SEPARATOR ","»
-					"«state.genStatePathName»"
+				«FOR node : orderedStateNodes SEPARATOR ","»
+					"«(node.stateGraphNode as State).genStatePathName»"
 				«ENDFOR»
 			};
 
@@ -54,7 +52,7 @@ class StateMachineGen extends GenericStateMachineGenerator {
 «««				history[i] = NO_STATE;
 «««			}
 		// history
-		protected int history[] = {NO_STATE, NO_STATE«FOR state : states», NO_STATE«ENDFOR»};
+		protected int history[] = {NO_STATE, NO_STATE«FOR state : orderedStateNodes», NO_STATE«ENDFOR»};
 
 		private void setState(int new_state) {
 			«IF Main::settings.generateMSCInstrumentation»
@@ -84,4 +82,28 @@ class StateMachineGen extends GenericStateMachineGenerator {
 	def getHistorySize(ExpandedActorClass xpac) {
 		xpac.actorClass.getAllBaseStates().size+2
 	}
+
+	private static class NodeComparator implements Comparator<Node> {
+		
+		// it is crucial that we obey the order that is used for state IDs
+		// that means we have to collect base classes first and each base class list with leaf states last
+		override int compare(Node o1, Node o2) {
+			if (o1.inheritanceLevel==o2.inheritanceLevel) {
+				if (o1.isLeaf && o2.isLeaf) {
+					return 0
+				}
+				if (o1.isLeaf) {
+					return 1
+				}
+				if (o2.isLeaf) {
+					return -1
+				}
+				return 0
+			}
+			else {
+				return Integer.compare(o1.inheritanceLevel, o1.inheritanceLevel)
+			}
+		}
+		
+	}
 }
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Validator.java b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Validator.java
index 7123338d1..9a4b5e5c0 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Validator.java
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/Validator.java
@@ -13,7 +13,7 @@
 package org.eclipse.etrice.generator.java.gen;
 
 import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 
 import com.google.inject.Inject;
 
diff --git a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/VariableServiceGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/VariableServiceGen.xtend
index 7aeb82895..fe827aeac 100644
--- a/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/VariableServiceGen.xtend
+++ b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/VariableServiceGen.xtend
@@ -167,8 +167,8 @@ class VariableServiceGen {
 	def private genMinMaxCheck(List<Attribute> path, ActorClass ac){
 		var a = path.last
 		var aVarName = path.toAbsolutePath("_")
-		var min = configExt.getAttrClassConfigMinValue(ac, path) != null
-		var max = configExt.getAttrClassConfigMaxValue(ac, path) != null
+		var min = configExt.getAttrClassConfigMinValue(ac, path) !== null
+		var max = configExt.getAttrClassConfigMaxValue(ac, path) !== null
 		if(min || max)
 			'''
 				«IF a.size>0»for(«a.type.type.typeName» e : «aVarName»)
diff --git a/plugins/org.eclipse.etrice.generator.launch/src/org/eclipse/etrice/generator/launch/GeneratorMainTab.java b/plugins/org.eclipse.etrice.generator.launch/src/org/eclipse/etrice/generator/launch/GeneratorMainTab.java
index 7b473bd04..5858c02e8 100644
--- a/plugins/org.eclipse.etrice.generator.launch/src/org/eclipse/etrice/generator/launch/GeneratorMainTab.java
+++ b/plugins/org.eclipse.etrice.generator.launch/src/org/eclipse/etrice/generator/launch/GeneratorMainTab.java
@@ -134,7 +134,6 @@ public abstract class GeneratorMainTab extends AbstractLaunchConfigurationTab {
 	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
 	}
 
-	@SuppressWarnings("unchecked")
 	@Override
 	public void initializeFrom(ILaunchConfiguration configuration) {
 		try {
diff --git a/plugins/org.eclipse.etrice.generator.ui.cdt/src/org/eclipse/etrice/generator/ui/cdt/CProjectConfigurator.java b/plugins/org.eclipse.etrice.generator.ui.cdt/src/org/eclipse/etrice/generator/ui/cdt/CProjectConfigurator.java
index 3fe5f9318..f068832b8 100644
--- a/plugins/org.eclipse.etrice.generator.ui.cdt/src/org/eclipse/etrice/generator/ui/cdt/CProjectConfigurator.java
+++ b/plugins/org.eclipse.etrice.generator.ui.cdt/src/org/eclipse/etrice/generator/ui/cdt/CProjectConfigurator.java
@@ -36,7 +36,7 @@ import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.core.runtime.jobs.ISchedulingRule;
 import org.eclipse.etrice.generator.ui.wizard.WizardHelpers;
 import org.eclipse.ui.actions.WorkspaceModifyOperation;
@@ -178,7 +178,7 @@ public class CProjectConfigurator extends ProjectConfigurator {
 
 			if (importOperation != null) {
 				importOperation.setContext(null);
-				importOperation.run(new SubProgressMonitor(progressMonitor, 1));
+				importOperation.run(SubMonitor.convert(progressMonitor, 1));
 				
 				IFolder folder = project.getFolder(C_RUNTIME_FOLDER_NAME);
 				folder = folder.getFolder("src");
@@ -270,7 +270,7 @@ public class CProjectConfigurator extends ProjectConfigurator {
 										structureProvider,
 										OVERWRITE_ALL_QUERY);
 								importOperation.setContext(null);
-								importOperation.run(new SubProgressMonitor(progressMonitor, 1));
+								importOperation.run(SubMonitor.convert(progressMonitor, 1));
 							}
 						}
 					}
diff --git a/plugins/org.eclipse.etrice.generator.ui/content/org.eclipse.etrice.template.java.zip b/plugins/org.eclipse.etrice.generator.ui/content/org.eclipse.etrice.template.java.zip
index 666728e68..d9838b1b3 100644
--- a/plugins/org.eclipse.etrice.generator.ui/content/org.eclipse.etrice.template.java.zip
+++ b/plugins/org.eclipse.etrice.generator.ui/content/org.eclipse.etrice.template.java.zip
diff --git a/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/EmptyProjectWizard.java b/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/EmptyProjectWizard.java
index 526d1eaa1..31d5b1e80 100644
--- a/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/EmptyProjectWizard.java
+++ b/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/EmptyProjectWizard.java
@@ -24,7 +24,7 @@ import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.emf.common.ui.dialogs.DiagnosticDialog;
 import org.eclipse.emf.common.util.BasicDiagnostic;
 import org.eclipse.emf.common.util.BasicMonitor;
@@ -261,7 +261,7 @@ public class EmptyProjectWizard extends Wizard implements INewWizard {
 			
 			if(importOperation != null){
 				importOperation.setContext(getShell());
-				importOperation.run(new SubProgressMonitor(progressMonitor, 1));
+				importOperation.run(SubMonitor.convert(progressMonitor, 1));
 			}
 		}
 		catch (Exception e) {
diff --git a/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/ProjectCreator.java b/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/ProjectCreator.java
index 01a1f6b4c..e557ed747 100644
--- a/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/ProjectCreator.java
+++ b/plugins/org.eclipse.etrice.generator.ui/src/org/eclipse/etrice/generator/ui/wizard/ProjectCreator.java
@@ -32,7 +32,7 @@ import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.emf.common.util.BasicMonitor;
 import org.eclipse.emf.common.util.Monitor;
 import org.eclipse.emf.common.util.URI;
@@ -108,12 +108,11 @@ public class ProjectCreator {
 					projectDescription.setLocationURI(new java.net.URI(
 							projectLocationURI.toString()));
 				}
-				project.create(projectDescription, new SubProgressMonitor(
-						progressMonitor, 1));
-				project.open(new SubProgressMonitor(progressMonitor, 1));
+				project.create(projectDescription, SubMonitor.convert(progressMonitor, 1));
+				project.open(SubMonitor.convert(progressMonitor, 1));
 			} else {
 				projectDescription = project.getDescription();
-				project.open(new SubProgressMonitor(progressMonitor, 1));
+				project.open(SubMonitor.convert(progressMonitor, 1));
 				if (project.hasNature(JavaCore.NATURE_ID)) {
 					classpathEntries.addAll(Arrays.asList(javaProject
 							.getRawClasspath()));
@@ -140,7 +139,7 @@ public class ProjectCreator {
 				addBuilders(projectDescription, buildersToAdd);
 
 				project.setDescription(projectDescription,
-						new SubProgressMonitor(progressMonitor, 1));
+						SubMonitor.convert(progressMonitor, 1));
 
 				createSrcFolder(progressMonitor, project, classpathEntries,
 						javaSource);
@@ -174,23 +173,23 @@ public class ProjectCreator {
 				
 				javaProject.setRawClasspath(classpathEntries
 						.toArray(new IClasspathEntry[classpathEntries.size()]),
-						new SubProgressMonitor(progressMonitor, 1));
+						SubMonitor.convert(progressMonitor, 1));
 			}
 
 			if (isInitiallyEmpty) {
 				javaProject.setOutputLocation(
 						new Path("/" + javaSource.segment(0) + "/bin"),
-						new SubProgressMonitor(progressMonitor, 1));
+						SubMonitor.convert(progressMonitor, 1));
 			}
 
 			javaProject.setRawClasspath(classpathEntries
 					.toArray(new IClasspathEntry[classpathEntries.size()]),
-					new SubProgressMonitor(progressMonitor, 1));
+					SubMonitor.convert(progressMonitor, 1));
 
 			if (isInitiallyEmpty) {
 				javaProject.setOutputLocation(
 						new Path("/" + javaSource.segment(0) + "/bin"),
-						new SubProgressMonitor(progressMonitor, 1));
+						SubMonitor.convert(progressMonitor, 1));
 			}
 
 		} catch (Exception e) {
@@ -264,7 +263,7 @@ public class ProjectCreator {
 							.removeLastSegments(i));
 					if (!sourceContainer.exists()) {
 						((IFolder) sourceContainer).create(false, true,
-								new SubProgressMonitor(progressMonitor, 1));
+								SubMonitor.convert(progressMonitor, 1));
 					}
 				}
 			}
@@ -303,26 +302,23 @@ public class ProjectCreator {
 			IProject project = workspace.getRoot().getProject(path.segment(0));
 
 			if (forceRefresh) {
-				project.refreshLocal(IResource.DEPTH_INFINITE,
-						new SubProgressMonitor(progressMonitor, 1));
+				project.refreshLocal(IResource.DEPTH_INFINITE, SubMonitor.convert(progressMonitor, 1));
 			} else {
 				progressMonitor.worked(1);
 			}
 
 			if (!project.exists()) {
-				project.create(projectDescription, new SubProgressMonitor(
-						progressMonitor, 1));
-				project.open(new SubProgressMonitor(progressMonitor, 1));
+				project.create(projectDescription, SubMonitor.convert(progressMonitor, 1));
+				project.open(SubMonitor.convert(progressMonitor, 1));
 			} else {
-				project.open(new SubProgressMonitor(progressMonitor, 2));
+				project.open(SubMonitor.convert(progressMonitor, 2));
 			}
 
 			IContainer container = project;
 			for (int i = 1, length = path.segmentCount(); i < length; ++i) {
 				IFolder folder = container.getFolder(new Path(path.segment(i)));
 				if (!folder.exists()) {
-					folder.create(false, true, new SubProgressMonitor(
-							progressMonitor, 1));
+					folder.create(false, true, SubMonitor.convert(progressMonitor, 1));
 				} else {
 					progressMonitor.worked(1);
 				}
@@ -429,8 +425,7 @@ public class ProjectCreator {
 		ProjectCreator.addBuilders(description, Collections
 				.singletonList("org.eclipse.xtext.ui.shared.xtextBuilder"));
 
-		project.setDescription(description, new SubProgressMonitor(
-				progressMonitor, 1));
+		project.setDescription(description, SubMonitor.convert(progressMonitor, 1));
 	}
 
 	/**
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGenerator.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGenerator.java
index d0205d622..77329bcc8 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGenerator.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGenerator.java
@@ -32,7 +32,8 @@ import org.eclipse.etrice.core.fsm.fSM.DetailCode;
 import org.eclipse.etrice.core.genmodel.builder.GeneratorModelBuilder;
 import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
 import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
 import org.eclipse.etrice.core.room.DataClass;
 import org.eclipse.etrice.core.room.ProtocolClass;
 import org.eclipse.etrice.core.room.RoomModel;
@@ -585,7 +586,10 @@ public abstract class AbstractGenerator implements IDetailCodeTranslator {
 		for (ExpandedActorClass xpac : gmRoot.getXpActorClasses()) {
 			DetailCodeTranslator dct = new DetailCodeTranslator(xpac.getActorClass(), translationProvider, doTranslate);
 			translateDetailCodesOfTree(xpac.getActorClass(), dct);
-			translateDetailCodesOfTree(xpac.getStateMachine(), dct);
+			List<DetailCode> allDetailCodes = FsmGenExtensions.getAllDetailCodes(xpac.getGraphContainer().getGraph());
+			for (DetailCode dc : allDetailCodes) {
+				detailcode2string.put(dc, dct.translateDetailCode(dc));
+			}
 		}
 		
 		for (DataClass dc : gmRoot.getDataClasses()) {
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGeneratorBaseModule.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGeneratorBaseModule.java
index c2d502a13..ddd5703b0 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGeneratorBaseModule.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/AbstractGeneratorBaseModule.java
@@ -14,8 +14,8 @@ package org.eclipse.etrice.generator.base;
 
 import org.eclipse.emf.ecore.EValidator;
 import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 import org.eclipse.etrice.generator.fsm.base.Diagnostician;
 import org.eclipse.etrice.generator.fsm.base.ILineOutputLogger;
 import org.eclipse.etrice.generator.fsm.base.Logger;
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/DefaultTranslationProvider.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/DefaultTranslationProvider.java
index c33255324..a9911c4e0 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/DefaultTranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/DefaultTranslationProvider.java
@@ -12,7 +12,7 @@
 
 package org.eclipse.etrice.generator.base;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.DetailCode;
@@ -72,7 +72,7 @@ public class DefaultTranslationProvider extends DefaultFSMTranslationProvider im
 	 * @see org.eclipse.etrice.generator.base.ITranslationProvider#getOperationText(org.eclipse.etrice.core.room.Operation, java.util.ArrayList, java.lang.String)
 	 */
 	@Override
-	public String getOperationText(Operation op, ArrayList<String> args, String orig) {
+	public String getOperationText(Operation op, List<String> args, String orig) {
 		return orig;
 	}
 
@@ -122,7 +122,7 @@ public class DefaultTranslationProvider extends DefaultFSMTranslationProvider im
 	 */
 	@Override
 	public String getInterfaceItemOperationText(AbstractInterfaceItem item,
-			PortOperation op, ArrayList<String> args, String orig) {
+			PortOperation op, List<String> args, String orig) {
 		return orig;
 	}
 
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/IDataConfiguration.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/IDataConfiguration.java
index f599632d4..c0de1ee43 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/IDataConfiguration.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/IDataConfiguration.java
@@ -18,7 +18,7 @@ import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
 import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.Attribute;
 import org.eclipse.etrice.core.room.PortClass;
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ITranslationProvider.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ITranslationProvider.java
index 6fcd9a79d..603bf709e 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ITranslationProvider.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ITranslationProvider.java
@@ -12,7 +12,7 @@
 
 package org.eclipse.etrice.generator.base;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.room.Attribute;
@@ -78,7 +78,7 @@ public interface ITranslationProvider extends IFSMTranslationProvider {
 	 * @param orig the original text
 	 * @return the translation
 	 */
-	String getOperationText(Operation op, ArrayList<String> args, String orig);
+	String getOperationText(Operation op, List<String> args, String orig);
 	
 	/**
 	 * yields a sequence that reads data from a <b>data driven</b> port.
@@ -115,5 +115,5 @@ public interface ITranslationProvider extends IFSMTranslationProvider {
 	 * @return the translation
 	 */
 	String getInterfaceItemOperationText(AbstractInterfaceItem item,
-			PortOperation op, ArrayList<String> args, String orig);
+			PortOperation op, List<String> args, String orig);
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ModelLoader.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ModelLoader.java
index 3794a8562..841d6b17e 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ModelLoader.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ModelLoader.java
@@ -24,7 +24,7 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.etrice.core.common.scoping.ModelLocatorUriResolver;
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
 import org.eclipse.etrice.generator.fsm.base.NullLogger;
 import org.eclipse.xtext.EcoreUtil2;
 import org.eclipse.xtext.resource.XtextResourceSet;
@@ -153,10 +153,15 @@ public class ModelLoader {
 	 */
 	private boolean addResourceURI(String uri) {
 		URI can = null;
-		if (uri.startsWith("platform:/") || uri.startsWith("classpath:/") || uri.startsWith("file:/"))
+		try {
+			// try valid uri
 			can = URI.createURI(uri);
-		else
+		} catch(IllegalArgumentException e1) {
+		}
+		if(can == null || !(can.isFile() || can.isArchive() || can.isPlatform() || can.scheme() == "classpath")) {
+			// try file path
 			can = URI.createFileURI(uri);
+		}
 		
 		if (loadedModelURIs.contains(can))
 			return false;
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.xtend
index 35bb5ee0c..b1ccd0fcc 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.xtend
@@ -12,13 +12,17 @@
 
 package org.eclipse.etrice.generator.generic
 
+import com.google.inject.Inject
 import org.eclipse.etrice.core.fsm.fSM.GuardedTransition
 import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition
+import org.eclipse.etrice.core.fsm.fSM.RefinedState
 import org.eclipse.etrice.core.fsm.fSM.State
-import org.eclipse.etrice.core.fsm.fSM.Transition
 import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedModelComponent
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState
+import org.eclipse.etrice.core.fsm.util.FSMHelpers
+import org.eclipse.etrice.core.genmodel.fsm.TriggerExtensions
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
 import org.eclipse.etrice.generator.fsm.generic.AbstractStateMachineGenerator
 
 /**
@@ -26,30 +30,36 @@ import org.eclipse.etrice.generator.fsm.generic.AbstractStateMachineGenerator
  */
 class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 
+	@Inject
+	protected extension TriggerExtensions
+	
+	@Inject
+	protected extension FSMHelpers
+	
 	/**
 	 * generates the code of the whole state machine, consisting of constants + methods
 	 *
 	 * @param xpmc the {@link ExpandedModelComponent}
 	 * @return the generated code
 	 */
-	def genStateMachine(ExpandedModelComponent xpmc) '''
-		«genStateMachineConstants(xpmc)»
+	def genStateMachine(GraphContainer gc) '''
+		«genStateMachineConstants(gc)»
 
-		«genStateMachineMethods(xpmc, true)»
+		«genStateMachineMethods(gc, true)»
 	'''
 
 	/**
 	 * generates the constants for the state machine
 	 */
-	def genStateMachineConstants(ExpandedModelComponent xpmc) '''
+	def genStateMachineConstants(GraphContainer gc) '''
 		/* state IDs */
-		«xpmc.genStateIdConstants»
+		«gc.genStateIdConstants»
 
 		/* transition chains */
-		«xpmc.genTransitionChainConstants»
+		«gc.genTransitionChainConstants»
 
 		/* triggers */
-		«xpmc.genTriggerConstants»
+		«gc.genTriggerConstants»
 	'''
 
 	/**
@@ -59,17 +69,17 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 	 * @param generateImplemenation or declaration only
 	 * @return the generated code
 	 */
-	def genStateMachineMethods(ExpandedModelComponent xpmc, boolean generateImplementation) '''
-		«genExtra(xpmc, generateImplementation)»
+	def genStateMachineMethods(GraphContainer gc, boolean generateImplementation) '''
+		«genExtra(gc, generateImplementation)»
 
 		/* Entry and Exit Codes */
-		«xpmc.genEntryAndExitCodes(generateImplementation)»
+		«gc.genEntryAndExitCodes(generateImplementation)»
 
 		/* Action Codes */
-		«xpmc.genActionCodes(generateImplementation)»
+		«gc.genActionCodes(generateImplementation)»
 
 		/* State Switch Methods */
-		«xpmc.genStateSwitchMethods(generateImplementation)»
+		«gc.genStateSwitchMethods(generateImplementation)»
 	'''
 
 	/**
@@ -80,8 +90,8 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 	 * @param xpmc an expanded actor class
 	 * @return the generated code
 	 */
-	override String guard(TriggeredTransition tt, String trigger, ExpandedModelComponent mc) {
-		val tr = tt.triggers.findFirst(e|mc.isMatching(e, trigger))
+	override String genTriggeredTransitionGuard(Link tt, String trigger, GraphContainer gc) {
+		val tr = (tt.transition as TriggeredTransition).triggers.findFirst(trig|trig.isMatching(trigger))
 	'''
 		«IF tr.hasGuard()»
 			if («translator.getTranslatedCode(tr.guard.guard)»)
@@ -89,16 +99,15 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 	'''
 	}
 
-    override String guard(GuardedTransition tt, String trigger, ExpandedModelComponent mc) {
+    override String genGuardedTransitionGuard(Link link, String trigger, GraphContainer gc) {
         '''
-            «translator.getTranslatedCode(tt.guard)»
+            «translator.getTranslatedCode((link.transition as GuardedTransition).guard)»
         '''
     }
 
-	override String genActionCodeMethod(ExpandedModelComponent xpmc, Transition tr, boolean generateImplementation) {
-        var chain = xpmc.getChains(tr)
-        var hasArgs = !chain.empty && chain.forall[it.transition instanceof NonInitialTransition && !(it.transition instanceof GuardedTransition)]
-        val opScope = langExt.operationScope(xpmc.getClassName, false)
+	override String genActionCodeMethod(GraphContainer gc, Link link, boolean generateImplementation) {
+        var hasArgs = !link.chainHeads.empty && link.chainHeads.forall[transition instanceof NonInitialTransition && !(transition instanceof GuardedTransition)]
+        val opScope = langExt.operationScope(gc.className, false)
         val opScopePriv = if (langExt.usesInheritance) opScope else ""
         val ifItemPtr = "InterfaceItemBase"+langExt.pointerLiteral()
         val constIfItemPtr = if (langExt.usesPointers)
@@ -108,14 +117,14 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 
         if (generateImplementation) {
     	    '''
-                «langExt.accessLevelProtected»void «opScopePriv»«tr.getActionCodeOperationName()»(«langExt.selfPointer(xpmc.className, hasArgs)»«IF hasArgs»«constIfItemPtr» ifitem«transitionChainGenerator.generateArgumentList(xpmc, tr)»«ENDIF») {
-                    «translator.getTranslatedCode(tr.action)»
+                «langExt.accessLevelProtected»void «opScopePriv»«link.transition.getActionCodeOperationName()»(«langExt.selfPointer(gc.className, hasArgs)»«IF hasArgs»«constIfItemPtr» ifitem«transitionChainGenerator.generateArgumentList(gc, link)»«ENDIF») {
+                    «translator.getTranslatedCode(link.transition.action)»
                 }
     	    '''
         }
         else {
             '''
-                «langExt.accessLevelProtected»«langExt.makeOverridable»void «tr.getActionCodeOperationName()»(«langExt.selfPointer(xpmc.className, hasArgs)»«IF hasArgs»«constIfItemPtr» ifitem«transitionChainGenerator.generateArgumentList(xpmc, tr)»«ENDIF»);
+                «langExt.accessLevelProtected»«langExt.makeOverridable»void «link.transition.getActionCodeOperationName()»(«langExt.selfPointer(gc.className, hasArgs)»«IF hasArgs»«constIfItemPtr» ifitem«transitionChainGenerator.generateArgumentList(gc, link)»«ENDIF»);
             '''
         }
 	}
@@ -128,33 +137,33 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
 	 * @param generateImplementation if only declarations should be generated then <code>false</code> has to be passed
 	 * @return the generated code
 	 */
-	override String genActionCodeMethods(ExpandedModelComponent xpmc, State state, boolean generateImplementation) {
-		val mc = xpmc.modelComponent
-		val selfPtr = langExt.selfPointer(mc.className, false)
-		val opScope = langExt.operationScope(mc.className, false)
+	override String genActionCodeMethods(GraphContainer gc, Node node, boolean generateImplementation) {
+		val mc = gc.modelComponent
+		val selfPtr = langExt.selfPointer(gc.className, false)
+		val opScope = langExt.operationScope(gc.className, false)
 		val opScopePriv = if (langExt.usesInheritance)
 							opScope
 						else
 							""
+		val state = node.stateGraphNode as State
 		val entryOp = state.getEntryCodeOperationName()
 		val exitOp = state.getExitCodeOperationName()
 		val doOp = state.getDoCodeOperationName()
 		var entry = translator.getTranslatedCode(state.entryCode)
 		var exit = translator.getTranslatedCode(state.exitCode)
 		var docode = translator.getTranslatedCode(state.doCode)
-		if (state instanceof ExpandedRefinedState) {
-			val rs = state as ExpandedRefinedState
-			val inhEntry = translator.getTranslatedCode(rs.inheritedEntry)
-			val inhExit = translator.getTranslatedCode(rs.inheritedExit)
-			val inhDo = translator.getTranslatedCode(rs.inheritedDo)
+		if (state instanceof RefinedState) {
+			val inhEntry = translator.getTranslatedCode(state.inheritedEntryCode)
+			val inhExit = translator.getTranslatedCode(state.inheritedExitCode)
+			val inhDo = translator.getTranslatedCode(state.inheritedDoCode)
 			if (langExt.usesInheritance) {
 				// we call the super method in the generated code
 				val baseName = mc.base.className
-				if (rs.inheritedEntry.hasDetailCode)
+				if (state.inheritedEntryCode.hasDetailCode)
 					entry = langExt.superCall(baseName, entryOp, "") + entry
-				if (rs.inheritedExit.hasDetailCode)
+				if (state.inheritedExitCode.hasDetailCode)
 					exit = exit + langExt.superCall(baseName, exitOp, "")
-				if (rs.inheritedDo.hasDetailCode)
+				if (state.inheritedDoCode.hasDetailCode)
 					docode = langExt.superCall(baseName, doOp, "") + docode
 			}
 			else {
@@ -202,5 +211,5 @@ class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
      * @param generateImplementation or declaration only
      * @return the generated code
      */
-    def public genExtra(ExpandedModelComponent xpmc, boolean generateImplementation) {''''''}
+    def public genExtra(GraphContainer gc, boolean generateImplementation) {''''''}
 }
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ILanguageExtension.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ILanguageExtension.java
index ad1d53a6d..9234bd2e4 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ILanguageExtension.java
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ILanguageExtension.java
@@ -28,6 +28,8 @@ import org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase;
  * @author Henrik Rentz-Reichert
  */
 public interface ILanguageExtension extends ILanguageExtensionBase {
+
+	static final String GENERIC_DATA_NAME = "transitionData";
 	
 	/**
 	 * Produces necessary casts or data type keys for an attribute (array) value statement
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/PrepareFileSystem.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/PrepareFileSystem.xtend
index 4b61434e9..59c6ce46c 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/PrepareFileSystem.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/PrepareFileSystem.xtend
@@ -20,7 +20,7 @@ import java.util.HashSet
 import java.util.Set
 import org.eclipse.emf.ecore.resource.Resource
 import org.eclipse.etrice.core.genmodel.etricegen.Root
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.generator.fsm.base.IncrementalGenerationFileIo
 import org.eclipse.xtext.generator.JavaIoFileSystemAccess
 
@@ -41,7 +41,7 @@ class PrepareFileSystem {
 			if (e instanceof Root) {
 				for (mdl : (e as Root).models) {
 					val tgtpath = mdl.generationTargetPath
-					if (tgtpath!=null && !tgtpath.empty)
+					if (tgtpath!==null && !tgtpath.empty)
 						pathes.add(tgtpath)
 				}
 			}
@@ -58,7 +58,7 @@ class PrepareFileSystem {
 			if (e instanceof Root) {
 				for (mdl : (e as Root).models) {
 					val tgtpath = mdl.generationInfoPath
-					if (tgtpath!=null && !tgtpath.empty)
+					if (tgtpath!==null && !tgtpath.empty)
 						pathes.add(tgtpath)
 				}
 			}
@@ -80,7 +80,7 @@ class PrepareFileSystem {
 			if (e instanceof Root) {
 				for (mdl : (e as Root).models) {
 					val tgtpath = mdl.docGenerationTargetPath
-					if (tgtpath!=null && !tgtpath.empty)
+					if (tgtpath!==null && !tgtpath.empty)
 						pathes.add(tgtpath)
 				}
 			}
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ProcedureHelpers.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ProcedureHelpers.xtend
index 93e6473c4..c22b7784b 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ProcedureHelpers.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/ProcedureHelpers.xtend
@@ -17,7 +17,7 @@ import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.util.List
 import org.eclipse.etrice.core.fsm.fSM.DetailCode
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.ActorContainerClass
 import org.eclipse.etrice.core.room.Attribute
@@ -100,7 +100,7 @@ class ProcedureHelpers {
 
 	def private userCode(String code) {
 	'''
-		«IF code!=null && !code.empty»
+		«IF code!==null && !code.empty»
 			/*--------------------- begin user code ---------------------*/
 			«code»
 			/*--------------------- end user code ---------------------*/
@@ -136,7 +136,7 @@ class ProcedureHelpers {
 	 * @return the code for an array initializer
 	 */
 	def arrayInitializer(Attribute att) {
-		val dflt = if (att.defaultValueLiteral!=null) att.defaultValueLiteral else languageExt.defaultValue(att.type.type)
+		val dflt = if (att.defaultValueLiteral!==null) att.defaultValueLiteral else languageExt.defaultValue(att.type.type)
 
 		if (dflt.startsWith("{")) {
 			if (dflt.split(",").size!=att.size)
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/RoomExtensions.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/RoomExtensions.xtend
index 10c9933a1..531cb0bfc 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/RoomExtensions.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/RoomExtensions.xtend
@@ -122,7 +122,7 @@ class RoomExtensions extends FSMExtensions {
 	 */
 	def String getModelPath(EObject e) {
 		var res = e.eResource;
-		if (res==null) {
+		if (res===null) {
 			return ""
 		}
 		else {
@@ -174,7 +174,7 @@ class RoomExtensions extends FSMExtensions {
 	 */
 	def String getProjectPath(EObject e) {
 		val res = FileSystemHelpers::getProjectURI(e)
-		if (res==null) {
+		if (res===null) {
 			return ""
 		}
 
@@ -304,13 +304,13 @@ class RoomExtensions extends FSMExtensions {
 		val ArrayList<PortClass> result = newArrayList()
 		
 		var protocol = pc
-		while (protocol!=null) {
+		while (protocol!==null) {
 			if (conj) {
-				if (protocol.conjugated!=null)
+				if (protocol.conjugated!==null)
 					result.add(protocol.conjugated)
 			}
 			else {
-				if (protocol.regular!=null)
+				if (protocol.regular!==null)
 					result.add(protocol.regular)
 			}
 			
@@ -326,7 +326,7 @@ class RoomExtensions extends FSMExtensions {
 	 * @return <code>true</code> if a send handler is specified for this direction
 	 */
 	def boolean handlesSend(ProtocolClass pc, boolean conj) {
-		if (pc.getPortClass(conj)==null)
+		if (pc.getPortClass(conj)===null)
 			return false
 		else {
 			val allMessages = pc.getAllMessages(conj)
@@ -343,7 +343,7 @@ class RoomExtensions extends FSMExtensions {
 	 * @return <code>true</code> if a receive handler is specified for this direction
 	 */
 	def boolean handlesReceive(ProtocolClass pc, boolean conj) {
-		if (pc.getPortClass(conj)==null)
+		if (pc.getPortClass(conj)===null)
 			return false
 		else {
 			val allMessages = pc.getAllMessages(!conj)
@@ -396,7 +396,7 @@ class RoomExtensions extends FSMExtensions {
 	 */
 	def List<MessageHandler> getReceiveHandlers(ProtocolClass pc, boolean conj) {
 		val res = new ArrayList<MessageHandler>()
-		if (pc.getPortClass(conj)!=null) {
+		if (pc.getPortClass(conj)!==null) {
 			val allMessages = pc.getAllMessages(!conj)
 			for (hdlr : getSafeList(pc.getPortClass(conj).msgHandlers)) {
 				if (allMessages.contains(hdlr.msg))
@@ -430,7 +430,7 @@ class RoomExtensions extends FSMExtensions {
 	 * @return a list of defined send {@link MessageHandler} for this direction
 	 */
 	def List<MessageHandler> getSendHandlers(ProtocolClass pc, boolean conj) {
-		if (pc.getPortClass(conj)==null)
+		if (pc.getPortClass(conj)===null)
 			return Collections.emptyList
 		else {
 			val res = new ArrayList<MessageHandler>()
@@ -478,8 +478,8 @@ class RoomExtensions extends FSMExtensions {
 	 * 		void return type
 	 */
 	def boolean overridesStop(ActorClass ac) {
-		ac.operations.exists(e|e.name=="stop" && e.arguments.isEmpty && e.returnType==null)
-			|| (ac.actorBase!=null && ac.actorBase.overridesStop())
+		ac.operations.exists(e|e.name=="stop" && e.arguments.isEmpty && e.returnType===null)
+			|| (ac.actorBase!==null && ac.actorBase.overridesStop())
 	}
 
 	def getAllSubInstances(StructureInstance ssi) {
@@ -494,7 +494,7 @@ class RoomExtensions extends FSMExtensions {
 	}
 
 	def static List<MessageHandler> getSafeList(List<MessageHandler> msgHandlers) {
-		return if (msgHandlers==null) Collections.emptyList else msgHandlers 
+		return if (msgHandlers===null) Collections.emptyList else msgHandlers 
 	}
 
 }
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TestInstanceCreator.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TestInstanceCreator.xtend
index ac21fb5d2..53a4977aa 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TestInstanceCreator.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TestInstanceCreator.xtend
@@ -6,7 +6,7 @@ import org.eclipse.emf.ecore.resource.ResourceSet
 import org.eclipse.etrice.core.etmap.eTMap.ETMapFactory
 import org.eclipse.etrice.core.etphys.eTPhys.PhysicalModel
 import org.eclipse.etrice.core.etphys.eTPhys.PhysicalSystem
-import org.eclipse.etrice.core.genmodel.fsm.base.ILogger
+import org.eclipse.etrice.core.genmodel.fsm.ILogger
 import org.eclipse.etrice.core.room.RoomFactory
 import org.eclipse.etrice.core.room.RoomModel
 import org.eclipse.etrice.core.room.StructureClass
diff --git a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TypeHelpers.xtend b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TypeHelpers.xtend
index e96fc6595..10bc215e2 100644
--- a/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TypeHelpers.xtend
+++ b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/generic/TypeHelpers.xtend
@@ -144,9 +144,9 @@ class TypeHelpers {
 	
 	def String getAttrClassConfigValue(List<Attribute> attributePath, ActorClass actor, boolean inherite){
 		var result = dataConfigExt.getAttrClassConfigValue(actor, attributePath)
-		if(result == null && inherite){
+		if(result === null && inherite){
 			var base = actor.actorBase
-			while(base != null && result == null){
+			while(base !== null && result === null){
 				result = dataConfigExt.getAttrClassConfigValue(base, attributePath)
 				base = base.actorBase
 			}
@@ -157,7 +157,7 @@ class TypeHelpers {
 	
 	def String getAttrClassConfigValue(List<Attribute> attributePath, PortClass port){
 		var pc = port.protocolClass
-		if(pc == null)
+		if(pc === null)
 			return null
 		return dataConfigExt.getAttrClassConfigValue(pc, port.equals(pc.regular), attributePath)
 	}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/modelaware/JFaceHighlightStyles.xtend b/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/modelaware/JFaceHighlightStyles.xtend
index 1e0468e5a..a212c0c30 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/modelaware/JFaceHighlightStyles.xtend
+++ b/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/modelaware/JFaceHighlightStyles.xtend
@@ -58,6 +58,22 @@ class JFaceHighlightStyles extends AbstractHighlightStyles {
 		new TextAttribute(getColor(INTERFACE_ITEM_RGB))
 	}
 	
+	override getEnum() {
+		new TextAttribute(getColor(ENUM_RGB))
+	}
+	
+	override getDataClass() {
+		new TextAttribute(getColor(DATA_CLASS_RGB))
+	}
+	
+	override getPrimitiveType() {
+		new TextAttribute(getColor(PRIMITIVE_TYPE_RGB))
+	}
+	
+	override getExternalType() {
+		new TextAttribute(getColor(EXTERNAL_TYPE_RGB))
+	}
+	
 	protected Map<RGB, Color> fColorTable = newHashMap
 	
 	def private Color getColor(RGB rgb) {
diff --git a/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/sourceviewer/ActionCodeAssistProcessor.java b/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/sourceviewer/ActionCodeAssistProcessor.java
index 01340e419..25f23a5b5 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/sourceviewer/ActionCodeAssistProcessor.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.actioneditor/src/org/eclipse/etrice/ui/behavior/actioneditor/sourceviewer/ActionCodeAssistProcessor.java
@@ -13,7 +13,7 @@
 
 package org.eclipse.etrice.ui.behavior.actioneditor.sourceviewer;
 
-import org.eclipse.etrice.core.ui.RoomUiActivator;
+import org.eclipse.etrice.core.ui.RoomUiModule;
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider;
 import org.eclipse.etrice.expressions.ui.contentassist.RoomExpressionProposalProvider;
 import org.eclipse.jface.text.ITextViewer;
@@ -40,7 +40,7 @@ public class ActionCodeAssistProcessor implements IContentAssistProcessor {
 	public ActionCodeAssistProcessor(IDetailExpressionProvider exprProvider) {
 		super();
 		this.exprProvider = exprProvider;
-		RoomUiActivator.getDefault().getInjector(RoomUiActivator.ORG_ECLIPSE_ETRICE_CORE_ROOM).injectMembers(this);
+		RoomUiModule.getInjector().injectMembers(this);
 	}
 
 	/**
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/.classpath b/plugins/org.eclipse.etrice.ui.behavior.fsm/.classpath
index 1fa3e6803..87e8cd659 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/.classpath
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/.classpath
@@ -1,7 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="xtend-gen"/>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.ui.behavior.fsm/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.ui.behavior.fsm/META-INF/MANIFEST.MF
index 8e73b0042..af6a4bf54 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/META-INF/MANIFEST.MF
@@ -8,6 +8,7 @@ Bundle-Vendor: eTrice
 Require-Bundle: org.eclipse.etrice.core.common.ui;bundle-version="1.1.3",
  org.eclipse.etrice.ui.common.base;bundle-version="1.1.3",
  org.eclipse.etrice.core.fsm;bundle-version="1.1.3",
+ org.eclipse.etrice.core.genmodel.fsm;bundle-version="1.1.3",
  org.eclipse.etrice.core.fsm.ui;bundle-version="1.1.3",
  org.eclipse.graphiti;bundle-version="0.8.0",
  org.eclipse.graphiti.ui;bundle-version="0.8.0",
@@ -18,13 +19,16 @@ Require-Bundle: org.eclipse.etrice.core.common.ui;bundle-version="1.1.3",
  org.eclipse.xtext.ui;bundle-version="2.7.0",
  org.eclipse.xtend.lib;bundle-version="2.7.0",
  org.eclipse.xtext.ui.shared;bundle-version="2.7.0",
- org.eclipse.etrice.expressions.ui;bundle-version="1.1.3"
+ org.eclipse.etrice.expressions.ui;bundle-version="1.1.3",
+ org.eclipse.xtext.ui.shared;bundle-version="2.7.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
-Export-Package: org.eclipse.etrice.ui.behavior.fsm.actioneditor,
+Export-Package: org.eclipse.etrice.ui.behavior.fsm,
+ org.eclipse.etrice.ui.behavior.fsm.actioneditor,
  org.eclipse.etrice.ui.behavior.fsm.actioneditor.preferences,
  org.eclipse.etrice.ui.behavior.fsm.commands,
  org.eclipse.etrice.ui.behavior.fsm.dialogs,
  org.eclipse.etrice.ui.behavior.fsm.editor,
  org.eclipse.etrice.ui.behavior.fsm.provider,
- org.eclipse.etrice.ui.behavior.fsm.support
+ org.eclipse.etrice.ui.behavior.fsm.support,
+ org.eclipse.etrice.ui.behavior.fsm.support.util
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/PopulateDiagramCommand.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/PopulateDiagramCommand.java
index 28d00f9cc..6bc96f050 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/PopulateDiagramCommand.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/PopulateDiagramCommand.java
@@ -16,42 +16,33 @@ import org.eclipse.emf.transaction.RecordingCommand;
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.ui.behavior.fsm.support.ContextSwitcher;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
-import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.features.context.impl.UpdateContext;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.ui.services.GraphitiUi;
 
-import com.google.inject.Injector;
-
 
 public class PopulateDiagramCommand extends RecordingCommand {
 
+	private String providerId;
 	private ModelComponent mc;
 	private Diagram diagram;
-	private IFeatureProvider fp;
-	private Injector injector;
 
-	public PopulateDiagramCommand(String providerId, Diagram diag, ModelComponent mc, Injector injector, TransactionalEditingDomain domain) {
+	public PopulateDiagramCommand(String providerId, Diagram diag, ModelComponent mc, TransactionalEditingDomain domain) {
 		super(domain);
+		this.providerId = providerId;
 		this.diagram = diag;
 		this.mc = mc;
-		this.injector = injector;
-
-		IDiagramTypeProvider dtp = GraphitiUi.getExtensionManager().createDiagramTypeProvider(diagram, providerId); //$NON-NLS-1$
-		fp = dtp.getFeatureProvider();
 	}
 
 	@Override
 	protected void doExecute() {
+		IDiagramTypeProvider dtp = GraphitiUi.getExtensionManager().createDiagramTypeProvider(diagram, providerId); //$NON-NLS-1$
 		
-		fp.link(diagram, mc);
-		
-		// we use a temporary structure to create the whole tree
-		StateGraphContext tree = StateGraphContext.createContextTree(mc, injector);
-		//System.out.println(tree);
-		
-		FSMSupportUtil.getInstance().addStateGraph(tree, diagram, fp);
+		dtp.getFeatureProvider().link(diagram, mc);
+
+		UpdateContext ctx = new UpdateContext(diagram);
+		dtp.getFeatureProvider().getUpdateFeature(ctx).update(ctx);
 		
 		ContextSwitcher.switchTop(diagram);
 	}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/StateGraphContext.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/StateGraphContext.java
deleted file mode 100644
index 867ab3953..000000000
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/commands/StateGraphContext.java
+++ /dev/null
@@ -1,274 +0,0 @@
-package org.eclipse.etrice.ui.behavior.fsm.commands;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
-import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.RefinedState;
-import org.eclipse.etrice.core.fsm.fSM.SimpleState;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.ui.behavior.fsm.support.DefaultPositionProvider;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
-import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider;
-
-import com.google.inject.Injector;
-
-public class StateGraphContext {
-	private ArrayList<StateGraphContext> children = new ArrayList<StateGraphContext>();
-	
-	private StateGraph stateGraph;
-	private ArrayList<State> states = new ArrayList<State>();
-	private ArrayList<ChoicePoint> chPoints = new ArrayList<ChoicePoint>();
-	private ArrayList<TrPoint> trPoints = new ArrayList<TrPoint>();
-	private ArrayList<Transition> transitions = new ArrayList<Transition>();
-	private IPositionProvider positionProvider;
-	private HashMap<StateGraphItem, StateGraphContext> obj2ctx;
-	
-	public static StateGraphContext createContextTree(ModelComponent mc, Injector injector) {
-		
-		// the top level state graph is always the one of our actor class
-		if (mc.getStateMachine()==null || mc.getStateMachine().eIsProxy()) {
-			mc.setStateMachine(FSMFactory.eINSTANCE.createStateGraph());
-		}
-		
-		// base classes in reverse order
-		ArrayList<ModelComponent> classes = new ArrayList<ModelComponent>();
-		{
-			ModelComponent a = mc;
-			while (a!=null) {
-				classes.add(0, a);
-				a = a.getBase();
-			}
-		}
-		
-		// build and merge contexts from base classes to derived classes
-		StateGraphContext tree = null;
-		for (ModelComponent cls : classes) {
-			if (cls.getStateMachine()!=null) {
-				if (tree==null)
-					tree = new StateGraphContext(cls.getStateMachine(), new HashMap<StateGraphItem, StateGraphContext>());
-				else
-					tree.merge(cls.getStateMachine());
-			}
-		}
-		
-		tree.positionProvider = new DefaultPositionProvider(mc, injector);
-		makePositionsAvailableToChildrenContexts(tree);
-		
-		return tree;
-	}
-
-	private StateGraphContext(StateGraph sg, HashMap<StateGraphItem, StateGraphContext> obj2ctx) {
-		this.stateGraph = sg;
-		this.obj2ctx = obj2ctx;
-		
-		init(sg);
-	}
-
-	private void init(StateGraph sg) {
-		for (State s : sg.getStates()) {
-			states.add(s);
-			obj2ctx.put(s, this);
-		}
-		for (ChoicePoint cp : sg.getChPoints()) {
-			chPoints.add(cp);
-			obj2ctx.put(cp, this);
-		}
-		for (TrPoint tp : sg.getTrPoints()) {
-			trPoints.add(tp);
-			obj2ctx.put(tp, this);
-		}
-		for (Transition t : sg.getTransitions()) {
-			transitions.add(t);
-			obj2ctx.put(t, this);
-		}
-
-		// recurse
-		for (State s : sg.getStates()) {
-			if (s.getSubgraph()!=null)
-				children.add(new StateGraphContext(s.getSubgraph(), obj2ctx));
-		}
-	}
-
-	private void merge(StateGraph derived) {
-		stateGraph = derived;
-		
-		// add derived contents up to refined states
-		for (State s : derived.getStates()) {
-			if (s instanceof SimpleState) {
-				states.add(s);
-				obj2ctx.put(s, this);
-			}
-		}
-		for (ChoicePoint cp : derived.getChPoints()) {
-			chPoints.add(cp);
-			obj2ctx.put(cp, this);
-		}
-		for (TrPoint tp : derived.getTrPoints()) {
-			trPoints.add(tp);
-			obj2ctx.put(tp, this);
-		}
-		for (Transition t : derived.getTransitions()) {
-			transitions.add(t);
-			obj2ctx.put(t, this);
-		}
-
-		// recurse for non-refined states
-		for (State s : derived.getStates()) {
-			if (s instanceof SimpleState)
-				if (s.getSubgraph()!=null)
-					children.add(new StateGraphContext(s.getSubgraph(), obj2ctx));
-		}
-		
-		// refined states
-		for (State refined : derived.getStates()) {
-			if (refined instanceof RefinedState) {
-				State base = ((RefinedState) refined).getTarget();
-				StateGraphContext ctx = obj2ctx.get(base);
-				assert(ctx!=null): "should have visited base state already";
-				
-				// remove base and put refined in place
-				ctx.getStates().remove(base);
-				ctx.getStates().add(refined);
-				obj2ctx.put(refined, this);
-				
-				// merge sub contexts
-				if (FSMSupportUtil.getInstance().getFSMHelpers().hasDirectSubStructure(base)) {
-					StateGraphContext basesub = null;
-					for (StateGraphContext bs : ctx.getChildren()) {
-						if (bs.getParentState()==base) {
-							basesub = bs;
-							break;
-						}
-					}
-					if (basesub!=null) {
-						if (FSMSupportUtil.getInstance().getFSMHelpers().hasDirectSubStructure(refined)) {
-							basesub.merge(refined.getSubgraph());
-						}
-					}
-					else {
-						assert(false): "context not found";
-					}
-				}
-				else if (FSMSupportUtil.getInstance().getFSMHelpers().hasDirectSubStructure(refined)) {
-					StateGraphContext sub = new StateGraphContext(refined.getSubgraph(), obj2ctx);
-					ctx.getChildren().add(sub);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Propagate the position map to all children recursively
-	 * 
-	 * @param tree
-	 */
-	private static void makePositionsAvailableToChildrenContexts(StateGraphContext tree) {
-		for (StateGraphContext child : tree.getChildren()) {
-			child.positionProvider = tree.positionProvider;
-			makePositionsAvailableToChildrenContexts(child);
-		}
-	}
-
-	public State getParentState() {
-		if (stateGraph.eContainer() instanceof State)
-			return (State) stateGraph.eContainer();
-		
-		return null;
-	}
-
-	public ArrayList<StateGraphContext> getChildren() {
-		return children;
-	}
-
-	public ArrayList<State> getStates() {
-		return states;
-	}
-
-	public ArrayList<ChoicePoint> getChPoints() {
-		return chPoints;
-	}
-
-	public StateGraph getStateGraph() {
-		return stateGraph;
-	}
-
-	public ArrayList<TrPoint> getTrPoints() {
-		return trPoints;
-	}
-
-	public ArrayList<Transition> getTransitions() {
-		return transitions;
-	}
-
-	public IPositionProvider getPositionProvider() {
-		return positionProvider;
-	}
-	
-	/* (non-Javadoc)
-	 * @see java.lang.Object#toString()
-	 */
-	@Override
-	public String toString() {
-		return dump("");
-	}
-	
-	/**
-	 * @param indent
-	 * @return context tree in human readable form
-	 */
-	private String dump(String indent) {
-		StringBuilder result = new StringBuilder();
-		result.append(indent+">>> "+getText(stateGraph)+"\n");
-		indent += "  ";
-		for (State s : states) {
-			result.append(indent+getText(s)+"\n");
-		}
-		
-		for (StateGraphContext child : children) {
-			result.append(child.dump(indent));
-		}
-		return result.toString();
-	}
-
-	private String getText(StateGraph sg) {
-		ModelComponent mc = getModelComponent(sg);
-		EObject parent = sg.eContainer();
-		String item = parent instanceof ModelComponent? "diagram" : (parent.eClass().getName()+" "+((State)parent).getName());
-		return "state graph of "+item+" of "+(mc==null? "?":mc.getComponentName());
-	}
-
-	private String getText(StateGraphItem item) {
-		ModelComponent mc = getModelComponent(item);
-		return item.eClass().getName()+" "+item.getName()+" of "+(mc==null? "?":mc.getComponentName());
-	}
-
-	private ModelComponent getModelComponent(EObject obj) {
-		EObject parent = obj.eContainer();
-		while (parent!=null) {
-			if (parent instanceof ModelComponent)
-				return (ModelComponent) parent;
-			parent = parent.eContainer();
-		}
-		return null;
-	}
-	
-	public StateGraphContext getContext(StateGraphItem item) {
-		return obj2ctx.get(item);
-	}
-	
-	public StateGraph getInitialPoint(){
-		for(Transition t : transitions)
-			if(t instanceof InitialTransition)
-				return (StateGraph) t.eContainer();
-		return null;
-	}
-}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/AbstractMemberAwarePropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/AbstractMemberAwarePropertyDialog.java
index 90ebde21c..72419ec9d 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/AbstractMemberAwarePropertyDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/AbstractMemberAwarePropertyDialog.java
@@ -29,7 +29,7 @@ import org.eclipse.etrice.ui.behavior.fsm.actioneditor.ActionCodeEditorRegistry;
 import org.eclipse.etrice.ui.behavior.fsm.actioneditor.ActionCodeEditorRegistry.ActionCodeEditorRegistryEntry;
 import org.eclipse.etrice.ui.behavior.fsm.actioneditor.IActionCodeEditor;
 import org.eclipse.etrice.ui.behavior.fsm.actioneditor.preferences.PreferenceConstants;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.dialogs.AbstractPropertyDialog;
 import org.eclipse.etrice.ui.common.base.dialogs.MultiValidator2;
 import org.eclipse.jface.preference.IPreferenceStore;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/ChoicePointPropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/ChoicePointPropertyDialog.java
index 6eb48c402..ccdc035e0 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/ChoicePointPropertyDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/ChoicePointPropertyDialog.java
@@ -9,7 +9,7 @@ import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
 import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
 import org.eclipse.etrice.core.fsm.validation.FSMValidationUtilXtend.Result;
 import org.eclipse.etrice.ui.behavior.fsm.Activator;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.dialogs.AbstractPropertyDialog;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Composite;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TrPointPropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TrPointPropertyDialog.java
index d9a369885..7c0fd40d5 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TrPointPropertyDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TrPointPropertyDialog.java
@@ -10,7 +10,7 @@ import org.eclipse.etrice.core.fsm.fSM.TrPoint;
 import org.eclipse.etrice.core.fsm.fSM.TransitionPoint;
 import org.eclipse.etrice.core.fsm.validation.FSMValidationUtilXtend.Result;
 import org.eclipse.etrice.ui.behavior.fsm.Activator;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.dialogs.AbstractPropertyDialog;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Composite;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TransitionTriggerCompartment.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TransitionTriggerCompartment.java
index 1fcef7532..d86bc6790 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TransitionTriggerCompartment.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/dialogs/TransitionTriggerCompartment.java
@@ -25,7 +25,7 @@ import org.eclipse.etrice.core.fsm.fSM.Transition;
 import org.eclipse.etrice.core.fsm.fSM.Trigger;
 import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
 import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.dialogs.AbstractPropertyDialog;
 import org.eclipse.jface.viewers.IBaseLabelProvider;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMDiagramTypeProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMDiagramTypeProvider.java
index fa38f2706..80044564b 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMDiagramTypeProvider.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMDiagramTypeProvider.java
@@ -12,6 +12,8 @@
 
 package org.eclipse.etrice.ui.behavior.fsm.editor;
 
+import org.eclipse.etrice.ui.behavior.fsm.provider.GenModelProvider;
+import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.common.base.editor.AbstractBaseDiagramTypeProvider;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.platform.IDiagramContainer;
@@ -21,7 +23,15 @@ import org.eclipse.graphiti.platform.IDiagramContainer;
  * functionality provided by {@link AbstractFSMEditor}. Diagram editor plugins 
  * that extend {@link AbstractFSMEditor} should also extend and use this class.
  */
-public abstract class AbstractFSMDiagramTypeProvider extends AbstractBaseDiagramTypeProvider {
+public abstract class AbstractFSMDiagramTypeProvider extends AbstractBaseDiagramTypeProvider implements IInjectorProvider {
+	
+	public GenModelProvider getGenModelProvider() {
+		// create always new one for now
+//		Stopwatch timer = Stopwatch.createStarted();
+//		GenModelProvider genModelProvider = new GenModelProvider(this);
+//		System.out.println(timer.stop().elapsed(TimeUnit.MILLISECONDS));	
+		return new GenModelProvider(this);
+	}
 	
 	/* (non-Javadoc)
 	 * @see org.eclipse.graphiti.dt.AbstractDiagramTypeProvider#resourceReloaded(org.eclipse.graphiti.mm.pictograms.Diagram)
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMEditor.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMEditor.java
index 389a9ff45..bc2609c17 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMEditor.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/AbstractFSMEditor.java
@@ -13,6 +13,7 @@
 package org.eclipse.etrice.ui.behavior.fsm.editor;
 
 import java.util.ArrayList;
+import java.util.EventObject;
 import java.util.Map;
 
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -27,8 +28,9 @@ import org.eclipse.etrice.core.fsm.fSM.RefinedState;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
 import org.eclipse.etrice.core.fsm.util.FSMHelpers;
+import org.eclipse.etrice.core.fsm.validation.FSMValidationUtil;
 import org.eclipse.etrice.ui.behavior.fsm.support.ContextSwitcher;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.editor.DiagramEditorBase;
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
 import org.eclipse.graphiti.features.IFeatureProvider;
@@ -38,6 +40,8 @@ import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 import org.eclipse.graphiti.services.Graphiti;
 import org.eclipse.graphiti.ui.editor.DiagramBehavior;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.swt.widgets.Display;
 
 import com.google.common.base.Function;
 
@@ -139,6 +143,23 @@ public abstract class AbstractFSMEditor extends DiagramEditorBase {
 
 	@Override
 	public void doSave(IProgressMonitor monitor) {
+		
+		FSMValidationUtil fsmValidationUtil = FSMSupportUtil.getInstance().getFSMValidationUtil();
+		Diagram diagram = getDiagramTypeProvider().getDiagram();
+		ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(diagram);
+		if (mc.getStateMachine()!=null) {
+			for (State s : mc.getStateMachine().getStates()) {
+				if (s instanceof RefinedState) {
+					if (fsmValidationUtil.isRefinedStateEmpty((RefinedState) s)) {
+						MessageDialog.openError(Display.getCurrent().getActiveShell(),
+								"Check of Refined State",
+								"A Refined State with empty action codes must have a non-empty sub state graph.");
+						return;
+					}
+				}
+			}
+		}
+
 		getEditingDomain().getCommandStack().execute(new RecordingCommand(getEditingDomain()) {
 			protected void doExecute() {
 				cleanupBeforeSave();
@@ -270,4 +291,10 @@ public abstract class AbstractFSMEditor extends DiagramEditorBase {
 		featureProvider.updateIfPossible(updateCtx);
 		diagramTypeProvider.getDiagramBehavior().refresh();
 	}
+	
+	@Override
+	public void commandStackChanged(EventObject event) {
+		// TODO Auto-generated method stub
+		super.commandStackChanged(event);
+	}
 }
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/BehaviorExporter.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/BehaviorExporter.java
index 782b7a916..95d2b3499 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/BehaviorExporter.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/BehaviorExporter.java
@@ -18,7 +18,7 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.export.DiagramExporter;
 import org.eclipse.etrice.ui.common.base.export.IBulkDiagramExporter;
 import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/DiagnosingModelObserver.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/DiagnosingModelObserver.java
index ba29924be..8a7eea9a3 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/DiagnosingModelObserver.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/editor/DiagnosingModelObserver.java
@@ -23,6 +23,7 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.util.Diagnostician;
 import org.eclipse.emf.ecore.util.EContentAdapter;
+import org.eclipse.etrice.core.fsm.fSM.DetailCode;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
 import org.eclipse.etrice.core.fsm.fSM.Trigger;
 import org.eclipse.xtext.validation.FeatureBasedDiagnostic;
@@ -116,10 +117,13 @@ public class DiagnosingModelObserver extends EContentAdapter {
 		super.notifyChanged(notification);
 
 		// Re-Validate on each notification except Adapter Removal.
-		// This prevents the editor to hang on dispose (since all adapters are
-		// then removed).
+		// This prevents the editor to hang on dispose (since all adapters are then removed).
 		if (notification.getEventType() < Notification.REMOVING_ADAPTER) {
-			updateElementDiagnosticMap();
+			if(!(notification.getNewValue() instanceof EObject) || notification.getNewValue() instanceof DetailCode) {
+				// Bug 531689: skip validation when user is typing in DetailCode or text field to prevent delay
+			} else {
+				updateElementDiagnosticMap();
+			}
 		}
 	}
 
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.xtend
new file mode 100644
index 000000000..d6ad81747
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.xtend
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.provider
+
+import com.google.common.collect.ArrayListMultimap
+import com.google.common.collect.Multimap
+import java.util.Collection
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.StateGraph
+import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil
+import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase
+import org.eclipse.graphiti.mm.pictograms.PictogramElement
+import org.eclipse.graphiti.mm.pictograms.PictogramLink
+import org.eclipse.graphiti.services.Graphiti
+
+/**
+ *  Provides the {@linkplain PictogramElement} objects of the base class diagram.
+ *  This is a reverse mapping from room business objects to linked base diagram pictograms.
+ * 
+ *  TODO: use fsmgenmodel instead
+ */
+class BaseDiagramProvider {
+
+	val Multimap<EObject, PictogramElement> baseDiagramBusinessObjs = ArrayListMultimap.create
+	val fsmHelpers = FSMSupportUtil.instance.FSMHelpers
+
+	new(AbstractFSMDiagramTypeProvider diagramTypeProvider) {
+		val diagramAccess = diagramTypeProvider.injector.getInstance(DiagramAccessBase)
+		val mc = Graphiti.linkService.getBusinessObjectForLinkedPictogramElement(diagramTypeProvider.diagram) as ModelComponent
+		val rs = diagramTypeProvider.diagram.eResource.resourceSet
+		
+		// open base diagrams => causes full recursive update or creation of all base diagrams
+		// all base diagrams have to be considered because inherited subgraph could not exist yet
+		val baseClasses = newArrayList => [
+			var base = mc.base
+			while(base !== null && it.add(base)) { 
+				base = base.base
+			}		
+		]
+		baseClasses.reverseView.forEach[ base |
+			val baseDiagram = diagramAccess.getDiagram(base, rs)	
+			if(baseDiagram !== null) {
+				// create mapping from business object to pictogram elements
+				EcoreUtil.ExternalCrossReferencer.find(baseDiagram).forEach [ targetEObj, eFeatureSetting |
+					eFeatureSetting.map[getEObject].filter(PictogramLink).map[pictogramElement].forEach [ pe |
+						put(mc, targetEObj, pe)
+					]
+				]
+				
+				// base diagram resource not needed anymore
+				rs.resources.remove(baseDiagram.eResource)		
+			}	
+		]
+	}
+	
+	private def put(ModelComponent mc, EObject obj, PictogramElement value) {
+		if (obj instanceof StateGraph) {
+			if (fsmHelpers.isTopLevel(obj)) {
+				// to find the initial point of the TOP level we need the ModelComponent's stateMachine as a key
+				baseDiagramBusinessObjs.put(mc.stateMachine, value)
+			}
+		}
+		baseDiagramBusinessObjs.put(obj, value)
+	}
+
+	def Collection<PictogramElement> getPictograms(EObject roomObj) {
+		if(roomObj === null) emptyList else baseDiagramBusinessObjs.get(roomObj)
+	}
+
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.xtend
new file mode 100644
index 000000000..7b9c50473
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.xtend
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.provider
+
+import java.util.Map
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.genmodel.fsm.BasicFsmGenBuilder
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider
+import org.eclipse.graphiti.dt.IDiagramTypeProvider
+import org.eclipse.graphiti.services.Graphiti
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement
+
+class GenModelProvider {
+
+	val BasicFsmGenBuilder builder
+	val IDiagramTypeProvider fsmDiagramProvider
+	var Map<EObject, FSMGenElement> graphMap = newHashMap
+
+	var GraphContainer modelInstance = null
+
+	new(AbstractFSMDiagramTypeProvider fsmDiagramProvider) {
+		this.fsmDiagramProvider = fsmDiagramProvider
+		builder = new BasicFsmGenBuilder(fsmDiagramProvider.injector)
+	}
+
+	def updateModel() {
+		Graphiti.linkService.getBusinessObjectForLinkedPictogramElement(fsmDiagramProvider.diagram) => [
+			modelInstance = if(it instanceof ModelComponent) builder.createTransformedModel(it) else null
+		]
+		if (modelInstance !== null) {
+			graphMap.clear
+			modelInstance.eAllContents.forEach [
+				switch (it) {
+					Graph: graphMap.put(stateGraph, it)
+					Node: graphMap.put(stateGraphNode, it)
+					Link: graphMap.put(transition, it)
+				}
+			]
+		}
+	}
+
+	def getModel() {
+		if (modelInstance === null) {
+			updateModel()
+		}
+
+		return modelInstance;
+	}
+
+	def <T extends FSMGenElement> getCasted(EObject roomObj) {
+		return graphMap.get(roomObj) as T
+	}
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/AbstractFSMProviderDispatcher.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/AbstractFSMProviderDispatcher.java
index 1b231a161..9fad672db 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/AbstractFSMProviderDispatcher.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/AbstractFSMProviderDispatcher.java
@@ -24,6 +24,7 @@ import org.eclipse.etrice.core.fsm.fSM.TrPoint;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
 import org.eclipse.etrice.core.fsm.fSM.util.FSMSwitch;
 import org.eclipse.etrice.core.fsm.naming.FSMFragmentProvider;
+import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider;
 import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.common.base.support.CantDeleteFeature;
 import org.eclipse.etrice.ui.common.base.support.CantRemoveFeature;
@@ -78,7 +79,7 @@ import org.eclipse.graphiti.util.IColorConstant;
 
 import com.google.inject.Injector;
 
-public abstract class AbstractFSMProviderDispatcher implements IInjectorProvider {
+public class AbstractFSMProviderDispatcher {
 
 	private class FeatureProviderSwitch extends FSMSwitch<IFeatureProvider> {
 		private ContainerShape parent = null;
@@ -235,9 +236,9 @@ public abstract class AbstractFSMProviderDispatcher implements IInjectorProvider
 
 		private IInjectorProvider injectorProvider;
 
-		public DispatchingFeatureProvider(IDiagramTypeProvider dtp, IInjectorProvider injectorProvider) {
+		public DispatchingFeatureProvider(AbstractFSMDiagramTypeProvider dtp) {
 			super(dtp);
-			this.injectorProvider = injectorProvider;
+			this.injectorProvider = dtp;
 		}
 		
 		@Override
@@ -550,9 +551,9 @@ public abstract class AbstractFSMProviderDispatcher implements IInjectorProvider
 	private DispatchingToolBehaviorProvider dispatchingBP;
 	
 	
-	public AbstractFSMProviderDispatcher(IDiagramTypeProvider dtp) {
+	public AbstractFSMProviderDispatcher(AbstractFSMDiagramTypeProvider dtp) {
 		// create those first before using them
-		dispatchingFP = new DispatchingFeatureProvider(dtp, this);
+		dispatchingFP = new DispatchingFeatureProvider(dtp);
 		dispatchingBP = new DispatchingToolBehaviorProvider(dtp);
 
 		stateGraphSupport = new StateGraphSupport(dtp, dispatchingFP);
@@ -582,6 +583,7 @@ public abstract class AbstractFSMProviderDispatcher implements IInjectorProvider
 		return featureSwitch.getCreateConnectionFeatures();
 	}
 	
+	@SafeVarargs
 	private static <T> T[] concatAll(T[] first, T[]... rest) {
 		int totalLength = first.length;
 		for (T[] array : rest) {
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.xtend
new file mode 100644
index 000000000..083c0e12e
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.xtend
@@ -0,0 +1,165 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support
+
+import java.util.List
+import org.eclipse.etrice.core.fsm.fSM.InitialTransition
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.RefinedState
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.StateGraph
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode
+import org.eclipse.etrice.core.fsm.fSM.TrPoint
+import org.eclipse.etrice.core.fsm.fSM.Transition
+import org.eclipse.etrice.ui.behavior.fsm.provider.BaseDiagramProvider
+import org.eclipse.graphiti.mm.algorithms.Text
+import org.eclipse.graphiti.mm.pictograms.Connection
+import org.eclipse.graphiti.mm.pictograms.FreeFormConnection
+import org.eclipse.graphiti.mm.pictograms.PictogramElement
+import org.eclipse.graphiti.services.Graphiti
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+/**
+ *  IPositionProvider based on {@linkplain BaseDiagramProvider}
+ * 	Logic copied from DefaultPositionProvider
+ */
+@FinalFieldsConstructor
+class BaseDiagramPositionProvider implements IPositionProvider {
+	
+	val BaseDiagramProvider baseDiagram
+	
+	// TODO: positions should not rely on graphics internals
+	def getMargin(StateGraphNode node) {
+		switch node {
+			State: StateSupport.MARGIN
+			TrPoint: TrPointSupport.MARGIN
+			default: 0
+		}
+	}
+	
+	// TODO: positions should not rely on graphics internals
+	def getMargin(StateGraph graph){
+		return 0
+	}
+	
+	def private toPosAndSize(PictogramElement pe, int margin){
+		val borderGa = (pe.eContainer as PictogramElement).graphicsAlgorithm.graphicsAlgorithmChildren.head
+		val ga = pe.graphicsAlgorithm
+		
+		val x = (ga.getX() / borderGa.width as double) * sx + margin
+		val y = (ga.getY() / borderGa.height as double) * sy + margin
+		val width = ((ga.getWidth() - 2 * margin) / borderGa.width as double) * sx
+		val height = ((ga.getHeight() - 2 * margin) / borderGa.height as double) * sy
+		
+		new PosAndSize(x as int, y as int, width as int, height as int)
+	}
+	
+	override getGraphPosAndSize(StateGraph sg) {
+		// graph is child of border shape, see initial point
+		val pe = baseDiagram.getPictograms(sg).findFirst[parentBo instanceof ModelComponent]
+		if (pe !== null){
+			val visibleGa = pe.graphicsAlgorithm.graphicsAlgorithmChildren.head
+			new PosAndSize(pe.graphicsAlgorithm.x, pe.graphicsAlgorithm.y, visibleGa.width, visibleGa.height)
+		}
+	}
+	
+	override getPoints(Transition trans) {
+		val pe = {
+			if (trans instanceof RefinedTransition)
+				baseDiagram.getPictograms(trans.target).head
+			else
+				baseDiagram.getPictograms(trans).head
+		}
+		newArrayList => [ pointList | 
+			if (pe instanceof Connection){
+				val graphPosAndSize = getGraphPosAndSize(trans.eContainer as StateGraph)
+				val text = pe.connectionDecorators.map[graphicsAlgorithm].filter(Text).head
+				if (text !== null){		
+					pointList += new Pos(
+						(((text.x / graphPosAndSize.width as double) * sx) as int), 
+						(((text.y / graphPosAndSize.height as double) * sy) as int)
+					)
+					if (pe instanceof FreeFormConnection){
+						pointList += pe.bendpoints.map[pt | new Pos(
+							(((pt.x / graphPosAndSize.width as double) * sx + x) as int) - StateGraphSupport.MARGIN, 
+							(((pt.y / graphPosAndSize.height as double) * sy + y) as int) - StateGraphSupport.MARGIN
+						)]
+					}
+				}
+			}
+		]
+	}
+	
+	override getPosition(StateGraphNode node) {
+		val getBasePos = [baseDiagram.getPictograms(it).findFirst[parentBo instanceof StateGraph]?.toPosAndSize(node.margin)]
+		
+		return if(node instanceof RefinedState){
+			// 1. RefinedState is base diagram
+			// 2. RefinedState target is in base diagram
+			getBasePos.apply(node)?:getBasePos.apply(node.target)
+		} else { 
+			getBasePos.apply(node)
+		}
+	}
+	
+	override getInitialPoint(StateGraph stateGraph) {
+		val initTransPe = baseDiagram.getPictograms(stateGraph.transitions.filter(InitialTransition).head).head
+		if(initTransPe instanceof Connection){
+			val sourceAnchorBo = Graphiti.linkService.getBusinessObjectForLinkedPictogramElement(initTransPe.start)
+			if(sourceAnchorBo instanceof StateGraph)
+				return sourceAnchorBo
+		}
+	}
+	
+	// TODO: better naming, this is the initial point
+	override getPosition(StateGraph graph) {
+		// initial point bo is graph and it is child of border shape
+		baseDiagram.getPictograms(graph).findFirst[parentBo instanceof StateGraph]?.toPosAndSize(graph.margin)
+	}
+	
+	override <T extends StateGraphNode> getPositions(List<T> items) {
+		items.map[baseDiagram.getPictograms(it).head?.toPosAndSize(it.margin)]
+	}
+	
+	override getSubPosition(StateGraphNode subNode) {
+		val pe = baseDiagram.getPictograms(subNode).findFirst[parentBo instanceof State]
+		if (pe !== null){
+			val parentPe = pe.eContainer as PictogramElement
+			val relX = pe.graphicsAlgorithm.getX() as double / (parentPe.graphicsAlgorithm.getWidth() - 2 * StateSupport.MARGIN)
+			val relY  = pe.graphicsAlgorithm.getY() as double / (parentPe.graphicsAlgorithm.getHeight() - 2 * StateSupport.MARGIN)
+			return #[relX, relY]		
+		}
+	}
+	
+	var int x
+	var int y
+	
+	override setPosition(int x, int y) {
+		this.x = x
+		this.y = y
+	}
+	
+	var double sx
+	var double sy
+	
+	override setScale(double sx, double sy) {
+		this.sx = sx
+		this.sy = sy
+	}
+	
+	def private getParentBo(PictogramElement pe) {
+		Graphiti.linkService.getBusinessObjectForLinkedPictogramElement(pe.eContainer as PictogramElement)
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ChoicePointSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ChoicePointSupport.java
index 8cb7bced3..d7891a575 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ChoicePointSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ChoicePointSupport.java
@@ -27,6 +27,8 @@ import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMEditor;
 import org.eclipse.etrice.ui.behavior.fsm.editor.DecoratorUtil;
 import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.behavior.fsm.provider.ImageProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.ModelEditingUtil;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCreateFeature;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCustomFeature;
 import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
@@ -92,7 +94,7 @@ import org.eclipse.ui.PlatformUI;
 import com.google.inject.Injector;
 
 public class ChoicePointSupport {
-	
+
 	public static final int ITEM_SIZE = (int) (StateGraphSupport.MARGIN*0.625);
 
 	protected static final int LINE_WIDTH = 2;
@@ -121,9 +123,8 @@ public class ChoicePointSupport {
 				StateGraph sg = (StateGraph) targetContainer.getLink().getBusinessObjects().get(0);
 				ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
 
-				boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
-				if (inherited) {
-					sg = FSMSupportUtil.getInstance().insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
+				if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+					sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
 				}
 
 				// create choice point and add it
@@ -193,7 +194,7 @@ public class ChoicePointSupport {
 				ContainerShape containerShape =
 					peCreateService.createContainerShape(sgShape, true);
 	
-				Graphiti.getPeService().setPropertyValue(containerShape, Constants.TYPE_KEY, Constants.TRP_TYPE);
+				Graphiti.getPeService().setPropertyValue(containerShape, Constants.TYPE_KEY, Constants.CP_TYPE);
 				
 				int x = context.getX()-ITEM_SIZE;
 				int y = context.getY()-ITEM_SIZE;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/Constants.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/Constants.java
index a7d17712c..9af3edb57 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/Constants.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/Constants.java
@@ -20,5 +20,6 @@ public interface Constants {
 	static final String STATE_TYPE = "state";
 	static final String CP_TYPE = "cp";
 	static final String TRP_TYPE = "trp";
+	static final String INI_TYPE = "ini";
 	static final String TRANS_TYPE = "trans";
 }
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ContextSwitcher.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ContextSwitcher.java
index cdde42d97..4256eaf38 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ContextSwitcher.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/ContextSwitcher.java
@@ -9,6 +9,7 @@ import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.RefinedState;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
 import org.eclipse.graphiti.mm.pictograms.Connection;
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DefaultPositionProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DefaultPositionProvider.java
deleted file mode 100644
index 3be1be189..000000000
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DefaultPositionProvider.java
+++ /dev/null
@@ -1,349 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2012 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.ui.behavior.fsm.support;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.ui.behavior.fsm.commands.StateGraphContext;
-import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase;
-import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
-import org.eclipse.graphiti.mm.algorithms.Text;
-import org.eclipse.graphiti.mm.algorithms.styles.Point;
-import org.eclipse.graphiti.mm.pictograms.Connection;
-import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
-import org.eclipse.graphiti.mm.pictograms.ContainerShape;
-import org.eclipse.graphiti.mm.pictograms.Diagram;
-import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
-import org.eclipse.graphiti.mm.pictograms.Shape;
-import org.eclipse.graphiti.services.Graphiti;
-import org.eclipse.graphiti.services.ILinkService;
-
-import com.google.inject.Injector;
-
-/**
- * @author Henrik Rentz-Reichert (initial contribution)
- *
- */
-public class DefaultPositionProvider implements IPositionProvider {
-	private static class Position {
-		double x;
-		double y;
-		double sx;
-		double sy;
-	}
-	
-	private HashMap<String, Position> obj2pos = new HashMap<String, Position>();
-	private HashMap<String, Position> subObj2pos = new HashMap<String, Position>();
-	private HashMap<String, ArrayList<Position>> trans2points = new HashMap<String, ArrayList<Position>>();
-	private HashMap<String, StateGraph> initialPointObj = new HashMap<String, StateGraph>();
-	private HashMap<String, PosAndSize> sg2sz = new HashMap<String, PosAndSize>();
-	private double scaleX;
-	private double scaleY;
-	private int posX, posY;
-	
-	public DefaultPositionProvider(ModelComponent mc, Injector injector) {
-		mapPositions(mc.getBase(), injector);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.ui.behavior.support.IPositionProvider#setScale(double, double)
-	 */
-	@Override
-	public void setScale(double sx, double sy) {
-		this.scaleX = sx;
-		this.scaleY = sy;
-	}
-	
-	@Override
-	public void setPosition(int x, int y){
-		this.posX = x;
-		this.posY = y;
-	}
-
-	public PosAndSize getPosition(StateGraphNode node) {
-		Position pos = obj2pos.get(FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath(node));
-		if (pos==null)
-			return null;
-		
-		int margin = getMargin(node);
-		PosAndSize pt = new PosAndSize(
-				(int) (pos.x * scaleX) + margin,
-				(int) (pos.y * scaleY) + margin,
-				(int) (pos.sx * scaleX),
-				(int) (pos.sy * scaleY)
-			);
-		return pt;
-	}
-	
-	@Override
-	public PosAndSize getPosition(StateGraph graph) {
-		EObject container = graph.eContainer();
-		String path = "#init";
-		if(container instanceof StateGraphNode)
-			path = FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath((StateGraphNode)container) + path;
-		Position pos = obj2pos.get(path);
-		
-		if (pos==null)
-			return null;
-		
-		int margin = getMargin(graph);
-		PosAndSize pt = new PosAndSize(
-			(int) (pos.x * scaleX) + margin,
-			(int) (pos.y * scaleY) + margin,
-			(int) (pos.sx * scaleX),
-			(int) (pos.sy * scaleY)
-		);
-		return pt;
-	}
-
-	public List<Pos> getPoints(Transition trans) {
-		ArrayList<Pos> result = new ArrayList<Pos>();
-		
-		ArrayList<Position> list = trans2points.get(FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath(trans));
-		if (list!=null) {
-			int i = 0;
-			for (Position p : list) {
-				Pos pos = 
-					new Pos(
-						(int) (p.x * scaleX) + ((i==0)?0:posX),
-						(int) (p.y * scaleY) + ((i==0)?0:posY)
-					);
-				result.add(pos);
-				i++;
-			}
-		}
-		
-		return result;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.ui.behavior.support.IPositionProvider#getPositions(java.util.List)
-	 */
-	@Override
-	public <T extends StateGraphNode> List<PosAndSize> getPositions(List<T> nodes) {
-		ArrayList<PosAndSize> result = new ArrayList<PosAndSize>(nodes.size());
-		
-		if (nodes.isEmpty())
-			return result;
-		
-		int n = 0;
-		for (T node : nodes) {
-			PosAndSize pt = getPosition(node);
-			result.add(pt);
-			if (pt==null)
-				n++;
-		}
-
-		int delta = (int) (scaleX/(n+1));
-		int pos = delta;
-		
-		int h = StateGraphSupport.MARGIN;
-		if (nodes.get(0) instanceof State)
-			h = StateGraphSupport.MARGIN + StateGraphSupport.DEFAULT_SIZE_Y/4;
-		else if (nodes.get(0) instanceof ChoicePoint)
-			h = StateGraphSupport.MARGIN + StateGraphSupport.DEFAULT_SIZE_Y/2;
-		else if (nodes.get(0) instanceof TrPoint)
-			h = StateGraphSupport.MARGIN;
-		else {
-			assert(false): "unexpected sub type";
-		}
-		
-		for (int i=0; i<nodes.size(); ++i) {
-			if (result.get(i)==null) {
-				PosAndSize pt = new PosAndSize(
-						pos,
-						h,
-						0,
-						0
-					);
-				result.set(i, pt);
-				
-				pos += delta;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Load base class diagrams recursively and put midpoint positions relative to boundary rectangle into map.
-	 * 
-	 * Positions are relative to the invisible rectangle. They are transformed to the border rectangle and normalized.
-	 * 
-	 * @param mc
-	 * @param obj2pos
-	 */
-	private void mapPositions(ModelComponent mc, Injector injector) {
-		if (mc==null)
-			return;
-
-		DiagramAccessBase diagramAccess = injector.getInstance(DiagramAccessBase.class);
-		Diagram diagram = diagramAccess.getDiagram(mc);
-		if (diagram==null)
-			return;
-		
-		StateGraphContext tree = StateGraphContext.createContextTree(FSMSupportUtil.getInstance().getModelComponent(diagram), injector);
-		FSMNameProvider fsmNameProvider = FSMSupportUtil.getInstance().getFSMNameProvider();
-		
-		ILinkService linkService = Graphiti.getLinkService();
-		for (Shape sgShape : diagram.getChildren()) {
-			// this is the level of StateGraphs
-			if (sgShape instanceof ContainerShape) {
-				EObject obj = linkService.getBusinessObjectForLinkedPictogramElement(sgShape);
-				GraphicsAlgorithm borderRect = sgShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
-				double width = borderRect.getWidth();
-				double height = borderRect.getHeight();
-				PosAndSize sz = new PosAndSize(
-						sgShape.getGraphicsAlgorithm().getX(), sgShape.getGraphicsAlgorithm().getY(),
-						borderRect.getWidth(), borderRect.getHeight());
-				sg2sz.put(fsmNameProvider.getFullPath((StateGraph) obj), sz);
-				for (Shape sgItemShape : ((ContainerShape)sgShape).getChildren()) {
-					// this is the level of States, TrPoints and ChoicePoints
-					obj = linkService.getBusinessObjectForLinkedPictogramElement(sgItemShape);
-					GraphicsAlgorithm ga = sgItemShape.getGraphicsAlgorithm();
-					if(ga==null)
-						continue;
-					int margin = 0;
-					String path = null;
-					if (obj instanceof StateGraphNode) {
-						StateGraphNode node = (StateGraphNode)obj;
-						margin = getMargin(node);
-						path = fsmNameProvider.getFullPath((StateGraphItem) obj);
-						
-						if(sgItemShape instanceof ContainerShape){
-							// sub items
-							for(Shape childShape : ((ContainerShape)sgItemShape).getChildren()){
-								EObject childObj = linkService.getBusinessObjectForLinkedPictogramElement(childShape);
-								if(childObj instanceof StateGraphItem){
-									GraphicsAlgorithm childGa = childShape.getGraphicsAlgorithm();
-									String childPath = fsmNameProvider.getFullPath((StateGraphItem) childObj);
-									if (childPath != null) {
-										Position pos = new Position();
-										pos.x = childGa.getX() / (double) (ga.getWidth() - 2 * margin);
-										pos.y = childGa.getY() / (double) (ga.getHeight() - 2 * margin);
-										pos.sx = -1;
-										pos.sy = -1;
-										subObj2pos.put(childPath, pos);
-									}
-								}
-							}
-						}
-					} else if(obj instanceof StateGraph){
-						StateGraph graph = (StateGraph)obj;
-						margin = getMargin(graph);
-						EObject container = graph.eContainer();
-						path = "#init";
-						if(container instanceof StateGraphNode)
-							path = fsmNameProvider.getFullPath((StateGraphNode)container) + path;
-						initialPointObj.put(path, graph);
-					}
-					if(path != null){
-						Position pos = new Position();
-						pos.x = ga.getX() / width;
-						pos.y = ga.getY() / height;
-						pos.sx = (ga.getWidth() - 2*margin) / width;
-						pos.sy = (ga.getHeight()- 2*margin) / height;
-						obj2pos.put(path, pos);
-					}
-					
-					// Entry and Exit Points on State borders are treated by the insertion of the State
-				}
-			}
-		}
-		
-		for (Connection conn : diagram.getConnections()) {
-			EObject obj = linkService.getBusinessObjectForLinkedPictogramElement(conn);
-			if (obj instanceof Transition) {
-				ConnectionDecorator cd = conn.getConnectionDecorators().get(1);
-				if (cd.getGraphicsAlgorithm() instanceof Text) {
-					Transition trans = (Transition) obj;
-					StateGraph sg = tree.getContext(trans).getStateGraph();
-					
-					// graph size
-					PosAndSize sz = sg2sz.get(fsmNameProvider.getFullPath(sg));
-					ArrayList<Position> points = new  ArrayList<Position>();
-					trans2points.put(fsmNameProvider.getFullPath((Transition) obj), points);
-					
-					// label position
-					Position pos = new Position();
-					pos.x = cd.getGraphicsAlgorithm().getX() / ((double)sz.getWidth());
-					pos.y = cd.getGraphicsAlgorithm().getY() / ((double)sz.getHeight());
-					points.add(pos);
-					
-					if (conn instanceof FreeFormConnection) {
-						for (Point bp : ((FreeFormConnection) conn).getBendpoints()) {
-							pos = new Position();
-							pos.x = (bp.getX() - sz.getX()) / ((double)sz.getWidth());
-							pos.y = (bp.getY() - sz.getY()) / ((double)sz.getHeight());
-							points.add(pos);
-						}
-					}
-				}
-
-			}
-		}
-		
-		// recursion
-		mapPositions(mc.getBase(), injector);
-	}
-
-	private int getMargin(StateGraphNode node) {
-		if (node instanceof State)
-			return StateSupport.MARGIN;
-		else if (node instanceof TrPoint)
-			return TrPointSupport.MARGIN;
-		
-		return 0;
-	}
-	
-	private int getMargin(StateGraph graph) {
-		return 0;
-	}
-	
-	public StateGraph getInitialPoint(StateGraph graph){
-		EObject container = graph.eContainer();
-		String path = "#init";
-		if(container instanceof StateGraphNode)
-			path = FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath((StateGraphNode)container) + path;
-		return initialPointObj.get(path);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.ui.behavior.support.IPositionProvider#getGraphSize(org.eclipse.etrice.core.room.StateGraph)
-	 */
-	@Override
-	public PosAndSize getGraphPosAndSize(StateGraph sg) {
-		return sg2sz.get(FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath(sg));
-	}
-
-	@Override
-	public double[] getSubPosition(StateGraphNode subNode) {
-		Position pos = subObj2pos.get(FSMSupportUtil.getInstance().getFSMNameProvider().getFullPath(subNode));
-		if (pos==null)
-			return null;
-		
-		return new double[]{pos.x, pos.y};
-	}
-}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DiagramUpdateFeature.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DiagramUpdateFeature.java
index 860e53b2f..bf9b7ceab 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DiagramUpdateFeature.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/DiagramUpdateFeature.java
@@ -14,10 +14,12 @@ package org.eclipse.etrice.ui.behavior.fsm.support;
 
 import java.util.ArrayList;
 
+import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.ui.behavior.fsm.commands.StateGraphContext;
-import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
+import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.DiagramEditingUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.features.IReason;
 import org.eclipse.graphiti.features.IRemoveFeature;
@@ -33,8 +35,6 @@ import org.eclipse.graphiti.mm.pictograms.ContainerShape;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 import org.eclipse.graphiti.platform.IDiagramBehavior;
 
-import com.google.inject.Injector;
-
 /**
  * @author Henrik Rentz-Reichert (initial contribution)
  *
@@ -63,9 +63,7 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 	 */
 	@Override
 	public IReason updateNeeded(IUpdateContext context) {
-		ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
-    	Injector injector = ((IInjectorProvider) getFeatureProvider()).getInjector();
-		StateGraphContext tree = StateGraphContext.createContextTree(mc, injector);
+		IStateGraphContext tree = createStateGraphContext();
 		
 		usedShapes.clear();
 		
@@ -108,9 +106,7 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 	 */
 	@Override
 	public boolean update(IUpdateContext context) {
-		ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
-    	Injector injector = ((IInjectorProvider) getFeatureProvider()).getInjector();
-		StateGraphContext tree = StateGraphContext.createContextTree(mc, injector);
+		IStateGraphContext tree = createStateGraphContext();
 
 		StateGraph currentStateGraph = ContextSwitcher.getCurrentStateGraph(getDiagram());
 		
@@ -169,7 +165,7 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 	 * @param ctx
 	 * @return
 	 */
-	private IReason updateNeeded(StateGraphContext ctx) {
+	private IReason updateNeeded(IStateGraphContext ctx) {
 		StateGraph sg = ctx.getStateGraph();
 		ContainerShape cont = findStateGraphContainer(sg);
 		if (cont==null)
@@ -196,7 +192,7 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 		}
 		
 		// recursion
-		for (StateGraphContext child : ctx.getChildren()) {
+		for (IStateGraphContext child : ctx.getChildren()) {
 			IReason needUpdate = updateNeeded(child);
 			if (needUpdate.toBoolean())
 				return needUpdate;
@@ -209,14 +205,14 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 	 * @param ctx
 	 * @return
 	 */
-	private boolean update(StateGraphContext ctx) {
+	private boolean update(IStateGraphContext ctx) {
 		boolean changed = false;
 		
 		StateGraph sg = ctx.getStateGraph();
 		ContainerShape cont = findStateGraphContainer(sg);
 		if (cont==null) {
 			// create
-			cont = FSMSupportUtil.getInstance().addStateGraph(ctx, getDiagram(), getFeatureProvider());
+			cont = DiagramEditingUtil.getInstance().addStateGraph(ctx, getDiagram(), getFeatureProvider());
 			changed = true;
 			usedShapes.add(cont);
 		}
@@ -242,7 +238,7 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 		}
 		
 		// recursion
-		for (StateGraphContext child : ctx.getChildren()) {
+		for (IStateGraphContext child : ctx.getChildren()) {
 			if (update(child))
 				changed = true;
 		}
@@ -262,5 +258,20 @@ public class DiagramUpdateFeature extends AbstractUpdateFeature {
 		}
 		return null;
 	}
+	
+	private IStateGraphContext createStateGraphContext(){
+		ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
+//    	Injector injector = ((IInjectorProvider) getFeatureProvider()).getInjector();
+//		StateGraphContext tree = StateGraphContext.createContextTree(mc, injector);
+		
+		// side effect on model, but diagram needs that for initial graph shape
+		if(mc.getStateMachine() == null || mc.getStateMachine().eIsProxy()){
+			mc.setStateMachine(FSMFactory.eINSTANCE.createStateGraph());
+		}
+		
+		IStateGraphContext tree = new GenModelStateGraphContext((AbstractFSMDiagramTypeProvider)getFeatureProvider().getDiagramTypeProvider());
+		
+		return tree;
+	}
 
 }
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/FSMSupportUtil.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/FSMSupportUtil.java
deleted file mode 100644
index 999b607e6..000000000
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/FSMSupportUtil.java
+++ /dev/null
@@ -1,997 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.ui.behavior.fsm.support;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.ChoicepointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
-import org.eclipse.etrice.core.fsm.fSM.ExitPoint;
-import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
-import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
-import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
-import org.eclipse.etrice.core.fsm.fSM.RefinedState;
-import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.StateGraph;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
-import org.eclipse.etrice.core.fsm.fSM.StateTerminal;
-import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.TrPoint;
-import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
-import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
-import org.eclipse.etrice.core.fsm.ui.FSMUiModule;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.fsm.util.FSMNewNamingUtil;
-import org.eclipse.etrice.core.fsm.validation.FSMValidationUtil;
-import org.eclipse.etrice.ui.behavior.fsm.commands.StateGraphContext;
-import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider.Pos;
-import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider.PosAndSize;
-import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
-import org.eclipse.graphiti.datatypes.ILocation;
-import org.eclipse.graphiti.features.IFeatureProvider;
-import org.eclipse.graphiti.features.IRemoveFeature;
-import org.eclipse.graphiti.features.context.IRemoveContext;
-import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
-import org.eclipse.graphiti.features.context.impl.AddContext;
-import org.eclipse.graphiti.features.context.impl.LayoutContext;
-import org.eclipse.graphiti.features.context.impl.RemoveContext;
-import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
-import org.eclipse.graphiti.mm.algorithms.styles.Point;
-import org.eclipse.graphiti.mm.pictograms.Anchor;
-import org.eclipse.graphiti.mm.pictograms.Connection;
-import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
-import org.eclipse.graphiti.mm.pictograms.ContainerShape;
-import org.eclipse.graphiti.mm.pictograms.Diagram;
-import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
-import org.eclipse.graphiti.mm.pictograms.PictogramElement;
-import org.eclipse.graphiti.mm.pictograms.Shape;
-import org.eclipse.graphiti.services.Graphiti;
-import org.eclipse.graphiti.services.IGaService;
-import org.eclipse.graphiti.services.ILinkService;
-
-import com.google.inject.Inject;
-import com.google.inject.Injector;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class FSMSupportUtil {
-
-	private static final String INITIAL = "init";
-	private static final String STATE = "state:";
-	private static final String TP = "tp:";
-	private static final String CP = "cp:";
-	private static final String SEP = ".";
-	private static FSMSupportUtil instance = null;
-
-	/**
-	 * @return the instance
-	 */
-	public static FSMSupportUtil getInstance() {
-		if (instance==null) {
-			// this class has members that have to be filled by the FSMUi injector
-			Injector injector = FSMUiModule.getInjector();
-	        instance = injector.getInstance(FSMSupportUtil.class);
-		}
-		return instance;
-	}
-
-	@Inject
-	private FSMHelpers fsmHelpers;
-	@Inject
-	private FSMValidationUtil fsmValidationUtil;
-	@Inject
-	private FSMNameProvider fsmNameProvider;
-	@Inject
-	private FSMNewNamingUtil fsmNewNamingUtil;
-
-	/**
-	 * @return the roomHelpers
-	 */
-	public FSMHelpers getFSMHelpers() {
-		return fsmHelpers;
-	}
-
-	/**
-	 * @return the validationUtil
-	 */
-	public FSMValidationUtil getFSMValidationUtil() {
-		return fsmValidationUtil;
-	}
-
-	/**
-	 * @return the roomUtil
-	 */
-	public FSMNewNamingUtil getFSMNewNamingUtil() {
-		return fsmNewNamingUtil;
-	}
-
-	/**
-	 * @return the roomNameProvider
-	 */
-	public FSMNameProvider getFSMNameProvider() {
-		return fsmNameProvider;
-	}
-
-	public EObject getOwnObject(EObject obj, ResourceSet rs) {
-		URI uri = EcoreUtil.getURI(obj);
-		EObject own = rs.getEObject(uri, true);
-		assert(own!=null): "own object must exist";
-		return own;
-	}
-
-	public boolean isInherited(Diagram diag, EObject obj) {
-		if(obj instanceof StateGraph)
-			obj = obj.eContainer();
-		else if (obj instanceof ModelComponent)
-			return ((ModelComponent) obj).getBase() != null;
-		
-		return  obj instanceof RefinedState || obj instanceof RefinedTransition || !EcoreUtil.isAncestor(getModelComponent(diag), obj);
-	}
-
-	public boolean showAsInherited(Diagram diag, State obj) {
-	
-		if (obj instanceof RefinedState)
-			return true;
-	
-		return fsmHelpers.getModelComponent(obj)!=getModelComponent(diag);
-	}
-
-	public Diagram getDiagram(GraphicsAlgorithm ga) {
-		if (ga.eContainer() instanceof GraphicsAlgorithm)
-			return getDiagram((GraphicsAlgorithm)ga.eContainer());
-		return getDiagram(ga.getPictogramElement());
-	}
-
-	/**
-	 * @param pictogramElement
-	 * @return
-	 */
-	public Diagram getDiagram(PictogramElement pe) {
-		while (pe.eContainer()!=null) {
-			if (pe.eContainer() instanceof Diagram)
-				return (Diagram) pe.eContainer();
-			pe = (PictogramElement) pe.eContainer();
-		}
-		return null;
-	}
-
-	public ModelComponent getModelComponent(Diagram diag) {
-		EObject bo = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(diag);
-		if (bo instanceof ModelComponent)
-			return (ModelComponent) bo;
-		return null;
-	}
-
-	/**
-	 * @param sg
-	 * @param mc
-	 * @param targetContainer
-	 * @param fp
-	 * @return
-	 */
-	public StateGraph insertRefinedState(StateGraph sg, ModelComponent mc, ContainerShape targetContainer,
-			IFeatureProvider fp) {
-				sg = getSubGraphOfRefinedStateFor((State) sg.eContainer(), mc);
-				fp.link(targetContainer, sg);
-				return sg;
-			}
-
-	/**
-	 * @param sg
-	 * @param mc
-	 * @param targetContainer
-	 */
-	public void undoInsertRefinedState(StateGraph sg, ModelComponent mc,
-			ContainerShape targetContainer, IFeatureProvider fp) {
-				RefinedState rs = (RefinedState) sg.eContainer();
-				fp.link(targetContainer, rs.getTarget().getSubgraph());
-				
-				if (!(fsmHelpers.hasDetailCode(rs.getEntryCode()) || fsmHelpers.hasDetailCode(rs.getExitCode()))) {
-					mc.getStateMachine().getStates().remove(rs);
-				}
-			}
-
-	/**
-	 * @param s
-	 * @param mc
-	 * @return
-	 */
-	public StateGraph getSubGraphOfRefinedStateFor(State s, ModelComponent mc) {
-		RefinedState rs = getRefinedStateFor(s, mc);
-		
-		if (rs.getSubgraph()==null)
-			rs.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
-	
-		return rs.getSubgraph();
-	}
-
-	public RefinedState getRefinedStateFor(State s, ModelComponent mc) {
-		HashMap<State, RefinedState> target2rs = new HashMap<State, RefinedState>();
-		for (State st : mc.getStateMachine().getStates()) {
-			if (st instanceof RefinedState)
-				target2rs.put(((RefinedState) st).getTarget(), (RefinedState) st);
-		}
-		
-		RefinedState rs = null;
-		
-		// do we already have a RefinedState pointing to s?
-		if (target2rs.containsKey(s)) {
-			rs = target2rs.get(s);
-		}
-		else {
-			// we have to create one and place it in the best fitting context
-			StateGraph sg = null;
-			State parent = s;
-			while (parent.eContainer().eContainer() instanceof State) {
-				parent = (State) s.eContainer().eContainer();
-				if (target2rs.containsKey(parent)) {
-					RefinedState bestFitting = target2rs.get(parent);
-					if (bestFitting.getSubgraph()==null)
-						bestFitting.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
-					sg = bestFitting.getSubgraph();
-					break;
-				}
-			}
-			
-			if (sg==null)
-				sg = mc.getStateMachine();
-			
-			rs = FSMFactory.eINSTANCE.createRefinedState();
-			rs.setTarget(s);
-			sg.getStates().add(rs);
-		}
-		return rs;
-	}
-
-	/**
-	 * @param state
-	 * @param diagram
-	 * @return
-	 */
-	public State getTargettingState(State state, Diagram diagram) {
-		ModelComponent mc = getModelComponent(diagram);
-		return fsmHelpers.getTargettingState(state, mc);
-	}
-
-	/**
-	 * This method exploits the fact that the immediate children of the diagram are
-	 * associated with the state graphs.
-	 * 
-	 * @param shape
-	 * @return the container shape that is associated with the state graph of the diagram
-	 */
-	public ContainerShape getStateGraphContainer(ContainerShape shape) {
-		while (shape!=null) {
-			ContainerShape parent = shape.getContainer();
-			if (parent instanceof Diagram)
-				return shape;
-			shape = parent;
-		}
-		return null;
-	}
-
-	public StateGraph getStateGraph(ContainerShape cs, IFeatureProvider fp) {
-		ContainerShape shape = getStateGraphContainer(cs);
-		Object bo = fp.getBusinessObjectForPictogramElement(shape);
-		if (bo instanceof StateGraph)
-			return (StateGraph) bo;
-		else
-			assert(false): "state graph expected";
-			
-		return null;
-	}
-
-	public TransitionTerminal getTransitionTerminal(Anchor anchor, IFeatureProvider fp) {
-		if (anchor != null) {
-			Object obj = fp.getBusinessObjectForPictogramElement(anchor.getParent());
-			if (obj instanceof TrPoint) {
-				Object parent = fp.getBusinessObjectForPictogramElement((ContainerShape) anchor.getParent().eContainer());
-				if (parent instanceof State) {
-					State state = (parent instanceof RefinedState)? ((RefinedState)parent).getTarget() : (State)parent;
-					SubStateTrPointTerminal sstpt = FSMFactory.eINSTANCE.createSubStateTrPointTerminal();
-					sstpt.setState(state);
-					sstpt.setTrPoint((TrPoint) obj);
-					return sstpt;
-				}
-				else {
-					TrPointTerminal tpt = FSMFactory.eINSTANCE.createTrPointTerminal();
-					tpt.setTrPoint((TrPoint) obj);
-					return tpt;
-				}
-			}
-			else if (obj instanceof State) {
-				State state = (obj instanceof RefinedState)? ((RefinedState)obj).getTarget() : (State)obj;
-				StateTerminal st = FSMFactory.eINSTANCE.createStateTerminal();
-				st.setState(state);
-				return st;
-			}
-			else if (obj instanceof ChoicePoint) {
-				ChoicepointTerminal ct = FSMFactory.eINSTANCE.createChoicepointTerminal();
-				ct.setCp((ChoicePoint) obj);
-				return ct;
-			}
-		}
-		return null;
-	}
-
-	public boolean isInitialPoint(Anchor anchor, IFeatureProvider fp) {
-		if (anchor!=null) {
-			Object obj = fp.getBusinessObjectForPictogramElement(anchor.getParent());
-			if (obj instanceof StateGraph) {
-				Object parent = fp.getBusinessObjectForPictogramElement((ContainerShape) anchor.getParent().eContainer());
-				if (parent instanceof StateGraph)
-					return true;
-			}
-		}
-		return false;
-	}
-
-	public boolean canConnect(Anchor asrc, Anchor atgt, ContainerShape cs, IFeatureProvider fp) {
-		return canConnect(asrc, atgt, null, cs, fp);
-	}
-
-	public boolean canConnect(Anchor asrc, Anchor atgt, Transition trans,
-			ContainerShape cs, IFeatureProvider fp) {
-				TransitionTerminal src = getTransitionTerminal(asrc, fp);
-				TransitionTerminal tgt = getTransitionTerminal(atgt, fp);
-				
-				if (src==null && !isInitialPoint(asrc, fp))
-					return false;
-				if (tgt==null)
-					return false;
-				
-				StateGraph sg = getStateGraph(cs, fp);
-				if (sg==null)
-					return false;
-				
-				return fsmValidationUtil.isConnectable(src, tgt, trans, sg).isOk();
-			}
-
-	/**
-	 * @param s the state whose sub structure should be deleted
-	 * @param mc the ModelComponent
-	 * @param diagram the current diagram
-	 * @param fp the feature provider
-	 */
-	public void deleteSubStructureRecursive(State s, ModelComponent mc,
-			Diagram diagram, IFeatureProvider fp) {
-				if (fsmHelpers.hasSubStructure(s, mc)) {
-					StateGraph subgraph = s.getSubgraph();
-					
-					// depth first
-					for (State st : subgraph.getStates()) {
-						deleteSubStructureRecursive(st, mc, diagram, fp);
-					}
-					
-					ContainerShape subShape = ContextSwitcher.getContext(diagram, subgraph);
-					CommonSupportUtil.deleteConnectionsRecursive(subShape, fp);
-					EcoreUtil.delete(subShape, true);
-				}
-			}
-
-	public List<State> getStates(ContainerShape shape, IFeatureProvider fp) {
-		return getStates(shape, fp, null, null);
-	}
-
-	private List<State> getStates(ContainerShape shape, IFeatureProvider fp, Map<String, Anchor> item2anchor, List<Shape> stateShapes) {
-		List<State> items = new ArrayList<State>();
-		for (Shape ch : shape.getChildren()) {
-			Object bo = fp.getBusinessObjectForPictogramElement(ch);
-			if (bo instanceof State) {
-				items.add((State)bo);
-				if (item2anchor!=null)
-					item2anchor.put(getKey((State)bo), ch.getAnchors().get(0));
-				if (stateShapes!=null)
-					stateShapes.add(ch);
-			}
-		}
-		return items;
-	}
-
-	public List<ChoicePoint> getChoicePoints(ContainerShape shape, IFeatureProvider fp) {
-		return getChoicePoints(shape, fp, null, null);
-	}
-
-	private List<ChoicePoint> getChoicePoints(ContainerShape shape, IFeatureProvider fp, Map<String, Anchor> item2anchor,
-			List<Shape> cpShapes) {
-				List<ChoicePoint> items = new ArrayList<ChoicePoint>();
-				for (Shape ch : shape.getChildren()) {
-					Object bo = fp.getBusinessObjectForPictogramElement(ch);
-					if (bo instanceof ChoicePoint) {
-						items.add((ChoicePoint)bo);
-						if (item2anchor!=null)
-							item2anchor.put(getKey((ChoicePoint)bo), ch.getAnchors().get(0));
-						if (cpShapes!=null)
-							cpShapes.add(ch);
-					}
-				}
-				return items;
-			}
-
-	public List<TrPoint> getTrPoints(StateGraph sg, ContainerShape shape, IFeatureProvider fp) {
-		return getTrPoints(sg, shape, fp, null, null);
-	}
-
-	private List<TrPoint> getTrPoints(StateGraph sg, ContainerShape shape, IFeatureProvider fp,
-			Map<String, Anchor> item2anchor, List<Shape> tpShapes) {
-				List<TrPoint> items = new ArrayList<TrPoint>();
-				for (Shape ch : shape.getChildren()) {
-					Object bo = fp.getBusinessObjectForPictogramElement(ch);
-					if (bo instanceof TrPoint) {
-						items.add((TrPoint)bo);
-						if (item2anchor!=null)
-							item2anchor.put(getKey((TrPoint)bo), ch.getAnchors().get(0));
-						if (tpShapes!=null)
-							tpShapes.add(ch);
-					}
-				}
-				return items;
-			}
-
-	/**
-	 * @param diagram
-	 * @param fp
-	 * @return
-	 */
-	public List<Transition> getTransitions(Diagram diagram, IFeatureProvider fp) {
-		List<Transition> transitions = new ArrayList<Transition>();
-		for (Connection conn : diagram.getConnections()) {
-			Object bo = fp.getBusinessObjectForPictogramElement(conn);
-			if (bo instanceof Transition)
-				transitions.add((Transition) bo);
-		}
-		return transitions;
-	}
-
-	private Map<Transition, Connection> getTransitionsMap(ContainerShape sgShape, IFeatureProvider fp) {
-		Diagram diagram = (Diagram) sgShape.eContainer();
-		Map<Transition, Connection> transitions = new HashMap<Transition, Connection>();
-		for (Connection conn : diagram.getConnections()) {
-			Object bo = fp.getBusinessObjectForPictogramElement(conn);
-			
-			// we only collect connections that have a starting point contained in our sgShape
-			if (bo instanceof Transition && EcoreUtil.isAncestor(sgShape, conn.getStart()))
-				transitions.put((Transition) bo, conn);
-		}
-		return transitions;
-	}
-
-	/**
-	 * @param sgShape
-	 * @param node2anchor
-	 */
-	private void getSubTpAnchors(ContainerShape sgShape, HashMap<String, Anchor> node2anchor) {
-		for (Shape childShape : sgShape.getChildren()) {
-			EObject bo = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(childShape);
-			if (bo instanceof State)
-				getAnchors((State) bo, childShape, node2anchor);
-		}
-	}
-
-	public ContainerShape addStateGraph(StateGraphContext ctx, Diagram diagram, IFeatureProvider fp) {
-		AddContext addContext = new AddContext();
-		addContext.setNewObject(ctx.getStateGraph());
-		addContext.setTargetContainer(diagram);
-		PosAndSize graphPosAndSize = ctx.getPositionProvider().getGraphPosAndSize(ctx.getStateGraph());
-		if (graphPosAndSize!=null) {
-			addContext.setX(graphPosAndSize.getX());
-			addContext.setY(graphPosAndSize.getY());
-			addContext.setWidth(graphPosAndSize.getWidth());
-			addContext.setHeight(graphPosAndSize.getHeight());
-		}
-		else {
-			addContext.setX(StateGraphSupport.MARGIN);
-			addContext.setY(StateGraphSupport.MARGIN);
-		}
-		
-		ContainerShape sgShape = (ContainerShape) fp.addIfPossible(addContext);
-		if (sgShape==null)
-			return null;
-		
-		final HashMap<String, Anchor> node2anchor = new HashMap<String, Anchor>();
-		
-		GraphicsAlgorithm borderRect = sgShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
-		ctx.getPositionProvider().setScale(borderRect.getWidth(), borderRect.getHeight());
-		ctx.getPositionProvider().setPosition(sgShape.getGraphicsAlgorithm().getX(), sgShape.getGraphicsAlgorithm().getY());
-		
-		addInitialPointIff(ctx, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-		addStateGraphNodes(ctx.getTrPoints(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
-		addStateGraphNodes(ctx.getStates(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
-		addStateGraphNodes(ctx.getChPoints(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
-	
-		for (StateGraphContext sub : ctx.getChildren()) {
-			addStateGraph(sub, diagram, fp);
-		}
-		
-		getSubTpAnchors(sgShape, node2anchor);
-		
-		addTransitions(ctx.getTransitions(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
-		
-		return sgShape;
-	}
-
-	private void addInitialPointIff(StateGraphContext ctx, IPositionProvider positionProvider, ContainerShape sgShape,
-			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
-			
-				// model
-				StateGraph sg = ctx.getInitialPoint();
-				if(sg==null)
-					// (super class) diagram
-					sg = positionProvider.getInitialPoint(ctx.getStateGraph());
-				if(sg==null)
-					return;
-				
-				PosAndSize pos = positionProvider.getPosition(sg);		
-				AddContext addContext = new AddContext();
-				addContext.setNewObject(sg);
-				addContext.setTargetContainer(sgShape);
-				if(pos != null){
-					addContext.setX(pos.getX());
-					addContext.setY(pos.getY());
-					if (pos.getWidth()>0 && pos.getHeight()>0) {
-						addContext.setWidth(pos.getWidth());
-						addContext.setHeight(pos.getHeight());
-					}
-				} else {
-					addContext.setX(3*StateGraphSupport.MARGIN);
-					addContext.setY(3*StateGraphSupport.MARGIN);
-				}
-				
-				ContainerShape pe = (ContainerShape) fp.addIfPossible(addContext);
-				assert(pe!=null): "initial point should have been created";
-				assert(!pe.getAnchors().isEmpty()): "initial point should have an anchor";
-				node2anchor.put(INITIAL, pe.getAnchors().get(0));
-			}
-
-	public void updateStateGraph(StateGraph sg, StateGraphContext ctx, ContainerShape sgShape,
-			IFeatureProvider fp) {
-			
-				HashMap<String, Anchor> node2anchor = new HashMap<String, Anchor>();
-				
-				GraphicsAlgorithm borderRect = sgShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
-				ctx.getPositionProvider().setScale(borderRect.getWidth(), borderRect.getHeight());
-				ctx.getPositionProvider().setPosition(sgShape.getGraphicsAlgorithm().getX(), sgShape.getGraphicsAlgorithm().getY());
-				
-				// states
-				{
-					ArrayList<Shape> shapes = new ArrayList<Shape>();
-					List<State> present = getStates(sgShape, fp, node2anchor, shapes);
-					checkDuplicates(present);
-					List<State> expected = ctx.getStates();
-					List<State> toAdd = new ArrayList<State>();
-					List<State> toUpdate = new ArrayList<State>();
-					List<State> toRemove = new ArrayList<State>();
-					for (State item : expected) {
-						if (present.contains(item))
-							toUpdate.add(item);
-						else
-							toAdd.add(item);
-					}
-					for(State item : present){
-						if(!expected.contains(item))
-							toRemove.add(item);
-					}
-			    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-			    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
-			    	removeGraphicalRepresentation(toRemove, shapes, fp);
-				}
-				
-				// transition points
-				{
-					ArrayList<Shape> shapes = new ArrayList<Shape>();
-					List<TrPoint> present = getTrPoints(sg, sgShape, fp, node2anchor, shapes);
-					checkDuplicates(present);
-					List<TrPoint> expected = ctx.getTrPoints();
-					List<TrPoint> toAdd = new ArrayList<TrPoint>();
-					List<TrPoint> toUpdate = new ArrayList<TrPoint>();
-					List<TrPoint> toRemove = new ArrayList<TrPoint>();
-					for (TrPoint item : expected) {
-						if (present.contains(item))
-							toUpdate.add(item);
-						else
-							toAdd.add(item);
-					}
-					for(TrPoint item : present){
-						if(!expected.contains(item))
-							toRemove.add(item);
-					}
-			    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-			    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
-			    	removeGraphicalRepresentation(toRemove, shapes, fp);
-				}
-				
-				// choice points
-				{
-					ArrayList<Shape> shapes = new ArrayList<Shape>();
-					List<ChoicePoint> present = getChoicePoints(sgShape, fp, node2anchor, shapes);
-					checkDuplicates(present);
-					List<ChoicePoint> expected = ctx.getChPoints();
-					List<ChoicePoint> toAdd = new ArrayList<ChoicePoint>();
-					List<ChoicePoint> toUpdate = new ArrayList<ChoicePoint>();
-					List<ChoicePoint> toRemove = new ArrayList<ChoicePoint>();
-					for (ChoicePoint item : expected) {
-						if (present.contains(item))
-							toUpdate.add(item);
-						else
-							toAdd.add(item);
-					}
-					for(ChoicePoint item : present){
-						if(!expected.contains(item))
-							toRemove.add(item);
-					}
-			    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-			    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
-			    	removeGraphicalRepresentation(toRemove, shapes, fp);
-				}
-				
-				getSubTpAnchors(sgShape, node2anchor);
-			
-				// initial point
-				{
-					// exists in this diagram ?
-					Shape present = null;
-					for (Shape ch : sgShape.getChildren()) {
-						Object bo = fp.getBusinessObjectForPictogramElement(ch);
-						if (bo instanceof StateGraph)
-							present = ch;
-					}
-					if(present != null)
-						node2anchor.put(INITIAL, present.getAnchors().get(0));
-					// exists in model ?
-					StateGraph expected = ctx.getInitialPoint();
-					if(expected == null)
-						// exists in (super class) diagram ? 
-						expected = ctx.getPositionProvider().getInitialPoint(ctx.getStateGraph());
-					if(expected != null && present == null)
-						addInitialPointIff(ctx, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-					else
-						updateInitialPoint(present, ctx.getPositionProvider(), fp);
-				}
-				
-				// transitions
-				{
-					// get transitions that belong to our state graph
-					// (for other connections we might not have the node anchors yet)
-					Map<Transition, Connection> present = getTransitionsMap(sgShape, fp);
-					List<Transition> expected = ctx.getTransitions();
-					List<Transition> toAdd = new ArrayList<Transition>();
-					List<Transition> toRemove = new ArrayList<Transition>();
-					for (Transition trans : expected)
-						if (!present.containsKey(trans))
-							toAdd.add(trans);
-					for(Transition item : present.keySet()){
-						if(!expected.contains(item))
-							toRemove.add(item);
-					}
-					addTransitions(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-					updateTransitions(present, ctx.getPositionProvider(), sgShape, fp, node2anchor);
-					removeGraphicalRepresentation(toRemove, present.values(), fp);
-				}
-			}
-
-	/**
-	 * @param items
-	 */
-	private void checkDuplicates(List<? extends StateGraphItem> items) {
-		for (StateGraphItem item : items) {
-			if (items.indexOf(item)!=items.lastIndexOf(item)) {
-				Assert.isTrue(
-						items.indexOf(item)==items.lastIndexOf(item),
-						"multiple occurrences of "+fsmNameProvider.getFullPath(item));
-			}
-		}
-	}
-
-	private void addTransitions(List<Transition> transitions, IPositionProvider positionProvider, ContainerShape sgShape,
-			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
-			
-				for (Transition trans : transitions) {
-					String from = (trans instanceof InitialTransition)? INITIAL:getKey(((NonInitialTransition)trans).getFrom());
-					String to = getKey(trans.getTo());
-					Anchor src = node2anchor.get(from);
-					Anchor dst = node2anchor.get(to);
-			
-					assert(src!=null && dst!=null): "transition endpoints must be present";
-					
-					AddConnectionContext context = new AddConnectionContext(src, dst);
-					context.setNewObject(trans);
-					PictogramElement pe = fp.addIfPossible(context);
-					if (pe instanceof FreeFormConnection) {
-						FreeFormConnection conn = (FreeFormConnection) pe;
-						
-						// JH: workaround for correct bend points of inherited self transition
-						conn.getBendpoints().clear();
-						
-						List<Pos> points = positionProvider.getPoints(trans);
-						if (points!=null && !points.isEmpty()) {
-							Iterator<Pos> it = points.iterator();
-							
-							// first is label position
-							Pos pos = it.next();
-							ConnectionDecorator cd = conn.getConnectionDecorators().get(1);
-							Graphiti.getGaService().setLocation(cd.getGraphicsAlgorithm(), pos.getX(), pos.getY());
-							
-							// remaining are bend points
-							while (it.hasNext()) {
-								pos = it.next();
-								Point pt = Graphiti.getGaService().createPoint(pos.getX(), pos.getY());
-								conn.getBendpoints().add(pt);
-							}
-						}
-						else if (src==dst) {
-							ILocation begin = Graphiti.getPeService().getLocationRelativeToDiagram(conn.getStart());
-							Point pt = Graphiti.getGaService().createPoint(begin.getX(), begin.getY()+StateGraphSupport.MARGIN*3);
-							conn.getBendpoints().add(pt);
-						}
-					}
-				}
-			}
-
-	private void addStateGraphNodes(List<? extends StateGraphNode> nodes, IPositionProvider positionProvider, ContainerShape sgShape,
-			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
-				
-				List<PosAndSize> positions = positionProvider.getPositions(nodes);
-				
-				int idx = 0;
-				for (StateGraphNode node : nodes) {
-					addStateGraphNode(node, sgShape, positions.get(idx), fp, node2anchor);
-					++idx;
-				}
-			}
-
-	private void addStateGraphNode(StateGraphNode tp, ContainerShape sgShape, PosAndSize pos,
-			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
-				AddContext addContext = new AddContext();
-				addContext.setNewObject(tp);
-				addContext.setTargetContainer(sgShape);
-				addContext.setX(pos.getX());
-				addContext.setY(pos.getY());
-				if (pos.getWidth()>0 && pos.getHeight()>0) {
-					addContext.setWidth(pos.getWidth());
-					addContext.setHeight(pos.getHeight());
-				}
-				
-				ContainerShape pe = (ContainerShape) fp.addIfPossible(addContext);
-				assert(pe!=null): tp.eClass().getName()+" should have been created";
-				assert(!pe.getAnchors().isEmpty()): tp.eClass().getName()+" should have an anchor";
-				node2anchor.put(getKey(tp), pe.getAnchors().get(0));
-			}
-
-	private void updateInitialPoint(Shape shape, IPositionProvider positionProvider, IFeatureProvider fp) {
-		if (shape==null)
-			return;
-		
-		StateGraph sg = (StateGraph) fp.getBusinessObjectForPictogramElement(shape);
-		PosAndSize ps = positionProvider.getPosition(sg);
-		if (ps==null)
-			return;
-		
-		// relocate and resize the invisible rectangle
-		GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
-	
-		Graphiti.getLayoutService().setLocationAndSize(
-			ga,
-			ps.getX(),
-			ps.getY(),
-			ps.getWidth(),
-			ps.getHeight()
-		);
-		
-		// have to call the layout to adjust the visible border
-		LayoutContext lc = new LayoutContext(shape);
-		fp.layoutIfPossible(lc);
-	}
-
-	private void updateStateGraphNodes(List<? extends StateGraphNode> nodes, List<Shape> shapes,
-			IPositionProvider positionProvider, IFeatureProvider fp) {
-					
-					ILinkService linkService = Graphiti.getLinkService();
-					IGaService gaService = Graphiti.getGaService();
-					
-					for (StateGraphNode node : nodes) {
-						PosAndSize ps = positionProvider.getPosition(node);
-						if (ps==null)
-							continue;
-						
-						// TODO: sub-optimal since quadratic effort - use combined list for nodes and shapes or similar solution
-						for (Shape shape : shapes) {
-							EObject bo = linkService.getBusinessObjectForLinkedPictogramElement(shape);
-							if (bo==node) {
-								// relocate and resize the invisible rectangle
-								GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
-//								System.out.println(node + ": "+ga.getX()+" "+ga.getY()+" "+ga.getWidth()+" "+ga.getHeight());
-//								System.out.println("  -> "+ps.getX()+" "+ps.getY()+" "+ps.getWidth()+" "+ps.getHeight());
-			
-								int margin = 0;
-								if (node instanceof State)
-									margin = StateSupport.MARGIN;
-								else if (node instanceof TrPoint)
-									margin = TrPointSupport.MARGIN;
-								
-								gaService.setLocationAndSize(
-										ga,
-										ps.getX()-margin,
-										ps.getY()-margin,
-										ps.getWidth()+2*margin,
-										ps.getHeight()+2*margin
-									);
-								
-								// have to call the layout to adjust the visible border
-								LayoutContext lc = new LayoutContext(shape);
-								fp.layoutIfPossible(lc);
-								
-								// update position of sub items
-								if(shape instanceof ContainerShape){
-									ContainerShape container = (ContainerShape) shape;
-									for(Shape child : container.getChildren()){
-										EObject childBo = linkService.getBusinessObjectForLinkedPictogramElement(child);
-										if(!(childBo instanceof StateGraphNode))
-											continue;
-										
-										double[] relPos = positionProvider.getSubPosition((StateGraphNode) childBo);
-										if(relPos != null)
-											gaService.setLocation(child.getGraphicsAlgorithm(), (int)(relPos[0] * ps.getWidth()), (int)(relPos[1]*ps.getHeight()));
-									}
-								}
-								
-								break;
-							}
-						}
-					}
-				}
-	
-	public void removeGraphicalRepresentation(Collection<? extends EObject> toRemove, Collection<? extends PictogramElement> pictograms, IFeatureProvider fp) {
-		for(EObject bo : toRemove)
-			for(PictogramElement pe : pictograms)
-				if(fp.getBusinessObjectForPictogramElement(pe) == bo){
-					IRemoveContext rc = new RemoveContext(pe);
-					IRemoveFeature removeFeature = fp.getRemoveFeature(rc);
-					if (removeFeature != null)
-						removeFeature.remove(rc);
-					break;
-				}
-	}
-
-	private void updateTransitions(Map<Transition, Connection> transitions, IPositionProvider positionProvider, ContainerShape sgShape,
-			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
-				
-				for(Entry<Transition, Connection> e: transitions.entrySet()){
-					Transition trans = e.getKey();
-					Connection conn = e.getValue();
-					
-					String from = (trans instanceof InitialTransition)? INITIAL:getKey(((NonInitialTransition)trans).getFrom());
-					String to = getKey(trans.getTo());
-					Anchor newSrc = node2anchor.get(from);
-					Anchor newDst = node2anchor.get(to);
-					
-					assert(newSrc!=null && newDst!=null): "transition endpoints must be present";
-					
-					if(conn.getStart()!=newSrc)
-						conn.setStart(newSrc);
-					if(conn.getEnd()!=newDst)
-						conn.setEnd(newDst);			
-					
-					List<Pos> points = positionProvider.getPoints(trans);
-					Iterator<Pos> it = points.iterator();
-					if (points==null || points.isEmpty())
-						continue;
-					
-					// first is label position
-					Pos pos = it.next();
-					ConnectionDecorator cd = conn.getConnectionDecorators().get(1);
-					Graphiti.getGaService().setLocation(cd.getGraphicsAlgorithm(), pos.getX(), pos.getY());
-					
-					if (conn instanceof FreeFormConnection) {
-						FreeFormConnection fconn = (FreeFormConnection) conn;
-			
-						// remaining are bend points
-						fconn.getBendpoints().clear();
-						List<Point> bendpoints = new ArrayList<Point>();
-						while (it.hasNext()) {
-							pos = it.next();
-							Point pt = Graphiti.getGaService().createPoint(pos.getX(), pos.getY());
-							bendpoints.add(pt);
-						}
-						fconn.getBendpoints().addAll(bendpoints);
-					}
-				}
-			}
-
-	private void getAnchors(State state, PictogramElement stateShape, final HashMap<String, Anchor> node2anchor) {
-		
-		if (stateShape instanceof ContainerShape) {
-			node2anchor.put(getKey(state), ((ContainerShape)stateShape).getAnchors().get(0));
-			for (Shape child : ((ContainerShape) stateShape).getChildren()) {
-				if (child instanceof ContainerShape) {
-					ContainerShape childShape = (ContainerShape) child;
-					if (!childShape.getAnchors().isEmpty()) {
-						if (!childShape.getLink().getBusinessObjects().isEmpty()) {
-							EObject obj = childShape.getLink().getBusinessObjects().get(0);
-							if (obj instanceof EntryPoint || obj instanceof ExitPoint) {
-								node2anchor.put(getKey(obj, true), childShape.getAnchors().get(0));
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	private String getKey(EObject obj) {
-		return getKey(obj, false);
-	}
-
-	private String getKey(EObject obj, boolean subTp) {
-		if (obj instanceof TrPoint) {
-			TrPoint tp = (TrPoint) obj;
-			if (!subTp)
-				return TP+tp.getName();
-			else {
-				if (tp.eContainer().eContainer() instanceof State) {
-					State s = (State) tp.eContainer().eContainer();
-					return TP+tp.getName()+SEP+s.getName();
-				}
-				else {
-					assert(false): "State expected";
-				}
-			}
-		}
-		else if (obj instanceof State) {
-			return STATE+((State)obj).getName();
-		}
-		else if (obj instanceof ChoicePoint) {
-			return CP+((ChoicePoint)obj).getName();
-		}
-		else if (obj instanceof TransitionTerminal) {
-			TransitionTerminal tt = (TransitionTerminal) obj;
-			if (tt instanceof ChoicepointTerminal) {
-				return CP+((ChoicepointTerminal)tt).getCp().getName();
-			}
-			else if (tt instanceof StateTerminal) {
-				return STATE+((StateTerminal)tt).getState().getName();
-			}
-			else if (tt instanceof SubStateTrPointTerminal) {
-				SubStateTrPointTerminal sstt = (SubStateTrPointTerminal) tt;
-				return TP+sstt.getTrPoint().getName()+SEP+sstt.getState().getName();
-			}
-			else if (tt instanceof TrPointTerminal) {
-				return TP+((TrPointTerminal)tt).getTrPoint().getName();
-			}
-			else {
-				assert(false): "unexpected sub type";
-			}
-		}
-		assert(false): "unexpected type";
-		return null;
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.xtend
new file mode 100644
index 000000000..97ee76065
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.xtend
@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support
+
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint
+import org.eclipse.etrice.core.fsm.fSM.InitialTransition
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.TrPoint
+import org.eclipse.etrice.core.fsm.fSM.Transition
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph
+import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider
+import org.eclipse.etrice.ui.behavior.fsm.provider.BaseDiagramProvider
+import org.eclipse.etrice.ui.behavior.fsm.provider.GenModelProvider
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition
+
+/**
+ *  StateGraphContext based on newfsmgen.
+ */
+class GenModelStateGraphContext implements IStateGraphContext {
+
+	val GenModelProvider genModel
+	val BaseDiagramPositionProvider baseDiagram
+	val Graph graph
+
+	new(AbstractFSMDiagramTypeProvider diagramTypeProvider){
+		this.genModel = diagramTypeProvider.genModelProvider
+		this.baseDiagram = new BaseDiagramPositionProvider(new BaseDiagramProvider(diagramTypeProvider))
+		this.graph = genModel.model.graph
+	}
+	
+	new(Graph graph, GenModelStateGraphContext other){
+		this.genModel = other.genModel
+		this.baseDiagram = other.baseDiagram
+		this.graph = graph
+	}
+	
+	//
+	// IStateGraphContext
+	//
+	
+	override getChPoints() {
+		graph.nodes.map[it.stateGraphNode].filter(ChoicePoint).toList
+	}
+	
+	override getChildren() {
+		graph.nodes.filter[it.subgraph !== null].map[new GenModelStateGraphContext(it.subgraph, this) as IStateGraphContext].toList
+	}
+	
+	override getInitialPoint() {
+		// return a Graph as initial point ?!?
+		if(!graph.links.map[transition].filter(InitialTransition).empty) graph.stateGraph
+	}
+	
+	override getParentState() {
+		graph.node.stateGraphNode as State
+	}
+	
+	override getPositionProvider() {
+		return baseDiagram
+	}
+	
+	override getStateGraph() {
+		graph.stateGraph
+	}
+	
+	override getStates() {
+		graph.nodes.map[it.stateGraphNode].filter(State).toList
+	}
+	
+	override getTrPoints() {
+		graph.nodes.map[it.stateGraphNode].filter(TrPoint).toList
+	}
+	
+	override getTransitions() {
+		val baseTransitions = graph.links.map[it.transition]
+		
+		// we take the union of Transitions and targets of RefinedTransitions
+		(baseTransitions.filter(Transition) + baseTransitions.filter(RefinedTransition).map[target]).toList
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/IStateGraphContext.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/IStateGraphContext.java
new file mode 100644
index 000000000..5764c136d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/IStateGraphContext.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support;
+
+import java.util.List;
+
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+
+/**
+ *  Interface to change implementation of StateGraphContext (newfsmgen)
+ */
+public interface IStateGraphContext {
+	
+	public State getParentState();
+
+	public List<IStateGraphContext> getChildren();
+
+	public List<State> getStates();
+
+	public List<ChoicePoint> getChPoints();
+
+	public StateGraph getStateGraph();
+
+	public List<TrPoint> getTrPoints();
+
+	public List<Transition> getTransitions();
+
+	public IPositionProvider getPositionProvider();
+	
+	public StateGraph getInitialPoint();
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/InitialPointSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/InitialPointSupport.java
index aa55c2c6b..c38007be6 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/InitialPointSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/InitialPointSupport.java
@@ -13,11 +13,14 @@
 package org.eclipse.etrice.ui.behavior.fsm.support;
 
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
 import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
 import org.eclipse.etrice.ui.behavior.fsm.provider.ImageProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.ModelEditingUtil;
 import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
 import org.eclipse.etrice.ui.common.base.support.DeleteWithoutConfirmFeature;
 import org.eclipse.etrice.ui.common.base.support.NoResizeFeature;
@@ -28,8 +31,10 @@ import org.eclipse.graphiti.features.ICreateFeature;
 import org.eclipse.graphiti.features.IDeleteFeature;
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.features.IMoveShapeFeature;
+import org.eclipse.graphiti.features.IReason;
 import org.eclipse.graphiti.features.IRemoveFeature;
 import org.eclipse.graphiti.features.IResizeShapeFeature;
+import org.eclipse.graphiti.features.IUpdateFeature;
 import org.eclipse.graphiti.features.context.IAddContext;
 import org.eclipse.graphiti.features.context.ICreateContext;
 import org.eclipse.graphiti.features.context.IDeleteContext;
@@ -37,11 +42,15 @@ import org.eclipse.graphiti.features.context.IMoveShapeContext;
 import org.eclipse.graphiti.features.context.IPictogramElementContext;
 import org.eclipse.graphiti.features.context.IRemoveContext;
 import org.eclipse.graphiti.features.context.IResizeShapeContext;
+import org.eclipse.graphiti.features.context.IUpdateContext;
 import org.eclipse.graphiti.features.context.impl.CreateConnectionContext;
+import org.eclipse.graphiti.features.context.impl.RemoveContext;
 import org.eclipse.graphiti.features.impl.AbstractAddFeature;
 import org.eclipse.graphiti.features.impl.AbstractCreateFeature;
+import org.eclipse.graphiti.features.impl.AbstractUpdateFeature;
 import org.eclipse.graphiti.features.impl.DefaultMoveShapeFeature;
 import org.eclipse.graphiti.features.impl.DefaultRemoveFeature;
+import org.eclipse.graphiti.features.impl.Reason;
 import org.eclipse.graphiti.mm.algorithms.Ellipse;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
 import org.eclipse.graphiti.mm.algorithms.Rectangle;
@@ -93,10 +102,9 @@ public class InitialPointSupport {
 				ContainerShape targetContainer = context.getTargetContainer();
 				StateGraph sg = (StateGraph) targetContainer.getLink().getBusinessObjects().get(0);
 
-				boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
-				if (inherited) {
-					ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
-					sg = FSMSupportUtil.getInstance().insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
+				ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
+				if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+					sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
 				}
 		        
 				// We don't create anything here since in the model the initial point is
@@ -155,14 +163,15 @@ public class InitialPointSupport {
 				ContainerShape sgShape = context.getTargetContainer();
 				StateGraph sg = (StateGraph) context.getNewObject();
 	
-				boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
+				Transition initTransition = FSMSupportUtil.getInstance().getFSMHelpers().getInitTransition(sg);
+				boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), initTransition);
 				
 				// CONTAINER SHAPE WITH RECTANGLE
 				IPeCreateService peCreateService = Graphiti.getPeCreateService();
 				ContainerShape containerShape =
 					peCreateService.createContainerShape(sgShape, true);
 	
-				Graphiti.getPeService().setPropertyValue(containerShape, Constants.TYPE_KEY, Constants.TRP_TYPE);
+				Graphiti.getPeService().setPropertyValue(containerShape, Constants.TYPE_KEY, Constants.INI_TYPE);
 				
 				int x = context.getX()-ITEM_SIZE;
 				int y = context.getY()-ITEM_SIZE;
@@ -215,7 +224,8 @@ public class InitialPointSupport {
 				if (canMove) {
 					Object bo = getBusinessObjectForPictogramElement(context.getPictogramElement());
 					if (bo instanceof StateGraph) {
-						return !FSMSupportUtil.getInstance().isInherited(getDiagram(), (StateGraph)bo);
+						Transition initTransition = FSMSupportUtil.getInstance().getFSMHelpers().getInitTransition((StateGraph) bo);
+						return !FSMSupportUtil.getInstance().isInherited(getDiagram(), initTransition);
 					}
 					return false;
 				}
@@ -224,6 +234,58 @@ public class InitialPointSupport {
 			}
 		}
 		
+		private class UpdateFeature extends AbstractUpdateFeature {
+
+			public UpdateFeature(IFeatureProvider fp) {
+				super(fp);
+			}
+
+			@Override
+			public boolean canUpdate(IUpdateContext context) {
+				Object bo = getBusinessObjectForPictogramElement(context.getPictogramElement());
+				if (bo instanceof EObject && ((EObject)bo).eIsProxy())
+					return true;
+				
+				return bo instanceof StateGraph;
+			}
+
+			@Override
+			public IReason updateNeeded(IUpdateContext context) {
+				Object bo = getBusinessObjectForPictogramElement(context.getPictogramElement());
+				if (bo instanceof EObject && ((EObject)bo).eIsProxy()) {
+					return Reason.createTrueReason("InitialPoint deleted from model");
+				}
+				
+				return Reason.createFalseReason();
+			}
+
+			@Override
+			public boolean update(IUpdateContext context) {
+				ContainerShape containerShape = (ContainerShape)context.getPictogramElement();
+				Object bo = getBusinessObjectForPictogramElement(containerShape);
+				if (bo instanceof EObject && ((EObject)bo).eIsProxy()) {
+					IRemoveContext rc = new RemoveContext(containerShape);
+					IFeatureProvider featureProvider = getFeatureProvider();
+					IRemoveFeature removeFeature = featureProvider.getRemoveFeature(rc);
+					if (removeFeature != null) {
+						removeFeature.remove(rc);
+					}
+					EcoreUtil.delete((EObject) bo);
+					return true;
+				}
+				
+				if (bo instanceof StateGraph) {
+					Transition initTransition = FSMSupportUtil.getInstance().getFSMHelpers().getInitTransition((StateGraph) bo);
+					boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), initTransition);
+					
+					Color dark = manageColor(inherited? INHERITED_COLOR:DARK_COLOR);
+					updateFigure(containerShape, dark, manageColor(BRIGHT_COLOR));
+				}
+				return true;
+			}
+			
+		}
+		
 		protected static class RemoveFeature extends DefaultRemoveFeature {
 
 			public RemoveFeature(IFeatureProvider fp) {
@@ -233,7 +295,8 @@ public class InitialPointSupport {
 			public boolean canRemove(IRemoveContext context) {
 				Object bo = getBusinessObjectForPictogramElement(context.getPictogramElement());
 				if (bo instanceof StateGraph) {
-					return !FSMSupportUtil.getInstance().isInherited(getDiagram(), (StateGraph) bo);
+					Transition initTransition = FSMSupportUtil.getInstance().getFSMHelpers().getInitTransition((StateGraph) bo);
+					return !FSMSupportUtil.getInstance().isInherited(getDiagram(), initTransition);
 				}
 				return false;
 			}
@@ -300,6 +363,11 @@ public class InitialPointSupport {
 			return new DeleteFeature(fp);
 		}
 		
+		@Override
+		public IUpdateFeature getUpdateFeature(IUpdateContext context) {
+			return new UpdateFeature(fp);
+		}
+		
 		protected static void createFigure( 
 				ContainerShape containerShape,
 				GraphicsAlgorithm invisibleRectangle, Color darkColor, Color brightColor) {
@@ -325,7 +393,18 @@ public class InitialPointSupport {
 				//containerShape.getAnchors().get(0).setReferencedGraphicsAlgorithm(rect);
 			}
 		}
-		
+
+		private static void updateFigure(PictogramElement pe, Color dark, Color bright) {
+			ContainerShape container = (ContainerShape)pe;
+			
+			// we clear the figure and rebuild it
+			GraphicsAlgorithm borderRect = pe.getGraphicsAlgorithm();
+			while (!borderRect.getGraphicsAlgorithmChildren().isEmpty()) {
+				EcoreUtil.delete(borderRect.getGraphicsAlgorithmChildren().get(0), true);
+			}
+			
+			createFigure(container, borderRect, dark, bright);
+		}
 	}
 
 	private class BehaviorProvider extends DefaultToolBehaviorProvider {
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphSupport.java
index e690751e6..16a1795b2 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphSupport.java
@@ -19,13 +19,16 @@ import org.eclipse.emf.common.util.Diagnostic;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.RefinedState;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
 import org.eclipse.etrice.core.fsm.fSM.TrPoint;
 import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.ui.behavior.fsm.commands.StateGraphContext;
+import org.eclipse.etrice.core.fsm.util.FSMHelpers;
 import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMEditor;
 import org.eclipse.etrice.ui.behavior.fsm.editor.DecoratorUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.DiagramEditingUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.etrice.ui.common.base.support.DeleteWithoutConfirmFeature;
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
 import org.eclipse.graphiti.features.IAddFeature;
@@ -72,6 +75,8 @@ import org.eclipse.graphiti.tb.ImageDecorator;
 import org.eclipse.graphiti.ui.features.DefaultFeatureProvider;
 import org.eclipse.graphiti.util.ColorConstant;
 import org.eclipse.graphiti.util.IColorConstant;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.swt.widgets.Display;
 
 import com.google.common.collect.Sets;
 
@@ -273,6 +278,22 @@ public class StateGraphSupport {
 				Object bo = getBusinessObjectForPictogramElement(container);
 				if (bo instanceof StateGraph) {
 					StateGraph sg = (StateGraph) bo;
+					if (sg.eContainer() instanceof RefinedState) {
+						RefinedState rs = (RefinedState) sg.eContainer();
+						FSMHelpers fsmHelpers = FSMSupportUtil.getInstance().getFSMHelpers();
+						if (fsmHelpers.isEmpty(sg)) {
+							// check action codes
+							boolean entryEmpty = fsmHelpers.getDetailCode(rs.getEntryCode()).trim().isEmpty();
+							boolean exitEmpty = fsmHelpers.getDetailCode(rs.getExitCode()).trim().isEmpty();
+							boolean doEmpty = fsmHelpers.getDetailCode(rs.getDoCode()).trim().isEmpty();
+							if (entryEmpty && exitEmpty && doEmpty) {
+								MessageDialog.openInformation(Display.getCurrent().getActiveShell(),
+										"Check of Refined State",
+										"A Refined State with empty action codes must have a non-empty sub state graph.");
+								return;
+							}
+						}
+					}
 					getDiagramBehavior().getDiagramContainer().selectPictogramElements(new PictogramElement[] {});
 					ContextSwitcher.goUp(getDiagram(), sg);
 				}
@@ -314,12 +335,12 @@ public class StateGraphSupport {
 				int obsolete = 0;
 				
 				if (context instanceof StateGraphUpdateContext) {
-					StateGraphContext ctx = ((StateGraphUpdateContext)context).getContext();
+					IStateGraphContext ctx = ((StateGraphUpdateContext)context).getContext();
 					
 					// check for states added in model not present in diagram (including inherited)
 					{
 						Set<State> expected = Sets.newHashSet(ctx.getStates());
-						Set<State> present = Sets.newHashSet(FSMSupportUtil.getInstance().getStates(shape, fp));
+						Set<State> present = Sets.newHashSet(DiagramEditingUtil.getInstance().getStates(shape, fp));
 						
 						if((missing = Sets.difference(expected, present).size()) > 0)
 							reason += missing+" missing states\n";	
@@ -331,7 +352,7 @@ public class StateGraphSupport {
 					{
 						missing = obsolete = 0;
 						Set<TrPoint> expected = Sets.newHashSet(ctx.getTrPoints());
-						Set<TrPoint> present = Sets.newHashSet(FSMSupportUtil.getInstance().getTrPoints(sg, shape, fp));
+						Set<TrPoint> present = Sets.newHashSet(DiagramEditingUtil.getInstance().getTrPoints(sg, shape, fp));
 						
 						if((missing = Sets.difference(expected, present).size()) > 0)
 							reason += missing+" missing transition points\n";	
@@ -343,7 +364,7 @@ public class StateGraphSupport {
 					{
 						missing = obsolete = 0;
 						Set<ChoicePoint> expected = Sets.newHashSet(ctx.getChPoints());
-						Set<ChoicePoint> present = Sets.newHashSet(FSMSupportUtil.getInstance().getChoicePoints(shape, fp));
+						Set<ChoicePoint> present = Sets.newHashSet(DiagramEditingUtil.getInstance().getChoicePoints(shape, fp));
 						
 						if((missing = Sets.difference(expected, present).size()) > 0)
 							reason += missing+" missing choice points\n";	
@@ -401,9 +422,9 @@ public class StateGraphSupport {
 				StateGraph sg = (StateGraph) bo;
 				
 				if (context instanceof StateGraphUpdateContext) {
-					StateGraphContext ctx = ((StateGraphUpdateContext)context).getContext();
+					IStateGraphContext ctx = ((StateGraphUpdateContext)context).getContext();
 
-					FSMSupportUtil.getInstance().updateStateGraph(sg, ctx, sgShape, fp);
+					DiagramEditingUtil.getInstance().updateStateGraph(sg, ctx, sgShape, fp);
 				}
 				
 				if (!sgShape.getChildren().isEmpty()) {
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphUpdateContext.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphUpdateContext.java
index 82c766c07..a1afa2204 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphUpdateContext.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateGraphUpdateContext.java
@@ -12,7 +12,6 @@
 
 package org.eclipse.etrice.ui.behavior.fsm.support;
 
-import org.eclipse.etrice.ui.behavior.fsm.commands.StateGraphContext;
 import org.eclipse.graphiti.features.context.impl.UpdateContext;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 
@@ -22,12 +21,12 @@ import org.eclipse.graphiti.mm.pictograms.PictogramElement;
  */
 public class StateGraphUpdateContext extends UpdateContext {
 
-	private StateGraphContext context;
+	private IStateGraphContext context;
 
 	/**
 	 * @param pictogramElement
 	 */
-	public StateGraphUpdateContext(PictogramElement pe, StateGraphContext ctx) {
+	public StateGraphUpdateContext(PictogramElement pe, IStateGraphContext ctx) {
 		super(pe);
 		
 		this.context = ctx;
@@ -36,7 +35,7 @@ public class StateGraphUpdateContext extends UpdateContext {
 	/**
 	 * @return the context
 	 */
-	public StateGraphContext getContext() {
+	public IStateGraphContext getContext() {
 		return context;
 	}
 
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateSupport.java
index 2ca43aadf..43d846452 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/StateSupport.java
@@ -30,6 +30,9 @@ import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMEditor;
 import org.eclipse.etrice.ui.behavior.fsm.editor.DecoratorUtil;
 import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.behavior.fsm.provider.ImageProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.DiagramEditingUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.ModelEditingUtil;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCreateFeature;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCustomFeature;
 import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
@@ -153,16 +156,12 @@ public class StateSupport {
 			public Object[] doCreate(ICreateContext context) {
 		        
 		        ContainerShape targetContainer = context.getTargetContainer();
-		        ModelComponent ac = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
-				StateGraph sg = (StateGraph) targetContainer.getLink().getBusinessObjects().get(0);
-		        
-				// hrr: was boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
-				// but if we are inside our own refined state it is treated as inherited which is wrong
-				boolean inherited = !EcoreUtil.isAncestor(FSMSupportUtil.getInstance().getModelComponent(getDiagram()), sg);
-				if (inherited) {
-					sg = FSMSupportUtil.getInstance().insertRefinedState(sg, ac, targetContainer, getFeatureProvider());
-				}
-				
+		        ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
+				StateGraph sg = (StateGraph) targetContainer.getLink().getBusinessObjects().get(0);			
+				if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+					sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
+
+				}		
 				// create new State and add it
 				SimpleState s = FSMFactory.eINSTANCE.createSimpleState();
 				s.setName(FSMSupportUtil.getInstance().getFSMNewNamingUtil().getUniqueName("state", sg));
@@ -171,7 +170,7 @@ public class StateSupport {
 	        	Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
 	        	Injector injector = ((IInjectorProvider) getFeatureProvider()).getInjector();
 	        	IFSMDialogFactory factory = injector.getInstance(IFSMDialogFactory.class);
-	        	IStatePropertyDialog dlg = factory.createStatePropertyDialog(shell, ac, s, true);
+	        	IStatePropertyDialog dlg = factory.createStatePropertyDialog(shell, mc, s, true);
 				if (dlg.open()==Window.OK) {
 					addGraphicalRepresentation(context, s);
 				
@@ -527,7 +526,7 @@ public class StateSupport {
 					
 					boolean isBaseClassState = FSMSupportUtil.getInstance().getFSMHelpers().getModelComponent(s)!=FSMSupportUtil.getInstance().getModelComponent(getDiagram());
 					if (isBaseClassState) {
-						newSG = FSMSupportUtil.getInstance().getSubGraphOfRefinedStateFor(s, FSMSupportUtil.getInstance().getModelComponent(getDiagram()));
+						newSG = ModelEditingUtil.getOrCreateSubGraphOfRefinedStateFor(s, FSMSupportUtil.getInstance().getModelComponent(getDiagram()));
 						s = (State) newSG.eContainer();
 						
 						// replace old business object with new refined state
@@ -590,7 +589,7 @@ public class StateSupport {
 				ContainerShape container = (ContainerShape)context.getPictogramElements()[0];
 				Object bo = getBusinessObjectForPictogramElement(container);
 				State s = (State) bo;
-				RefinedState rs = FSMSupportUtil.getInstance().getRefinedStateFor(s, FSMSupportUtil.getInstance().getModelComponent(getDiagram()));
+				RefinedState rs = ModelEditingUtil.getOrCreateRefinedStateFor(s, FSMSupportUtil.getInstance().getModelComponent(getDiagram()));
 				
 				// replace old business object with new refined state
 				link(container, rs);
@@ -599,6 +598,11 @@ public class StateSupport {
 				for (ICustomFeature cf : features) {
 					if (cf instanceof PropertyFeature) {
 						cf.execute(context);
+						if (!cf.hasDoneChanges()) {
+							// roll back
+							link(container, s);
+							EcoreUtil.remove(rs);
+						}
 						break;
 					}
 				}
@@ -830,7 +834,7 @@ public class StateSupport {
 				IFeatureProvider fp = getFeatureProvider();
 				Diagram diagram = getDiagram();
 				ModelComponent mc = FSMSupportUtil.getInstance().getFSMHelpers().getModelComponent(s);
-				FSMSupportUtil.getInstance().deleteSubStructureRecursive(s, mc, diagram, fp);
+				DiagramEditingUtil.getInstance().deleteSubStructureRecursive(s, mc, diagram, fp);
 				
 				ContainerShape container = (ContainerShape) context.getPictogramElement();
 				CommonSupportUtil.deleteConnectionsRecursive(container, fp);
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TrPointSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TrPointSupport.java
index cd2e86afb..bd07b6f83 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TrPointSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TrPointSupport.java
@@ -32,6 +32,8 @@ import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMEditor;
 import org.eclipse.etrice.ui.behavior.fsm.editor.DecoratorUtil;
 import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.behavior.fsm.provider.ImageProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.ModelEditingUtil;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCreateFeature;
 import org.eclipse.etrice.ui.common.base.support.ChangeAwareCustomFeature;
 import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
@@ -145,9 +147,9 @@ public class TrPointSupport {
 				ContainerShape targetContainer = context.getTargetContainer();
 		        ModelComponent mc = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
 				StateGraph sg = (StateGraph) targetContainer.getLink().getBusinessObjects().get(0);
-				boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
-				if (inherited) {
-					sg = FSMSupportUtil.getInstance().insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
+				
+				if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+					sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
 				}
 				
 		        // create transition point
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TransitionSupport.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TransitionSupport.java
index 6a7f9112d..f912cdfd7 100644
--- a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TransitionSupport.java
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/TransitionSupport.java
@@ -41,6 +41,8 @@ import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMEditor;
 import org.eclipse.etrice.ui.behavior.fsm.editor.DecoratorUtil;
 import org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider;
 import org.eclipse.etrice.ui.behavior.fsm.provider.ImageProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.ModelEditingUtil;
 import org.eclipse.etrice.ui.common.base.UIBaseActivator;
 import org.eclipse.etrice.ui.common.base.preferences.UIBasePreferenceConstants;
 import org.eclipse.etrice.ui.common.base.support.CantRemoveFeature;
@@ -267,11 +269,8 @@ public class TransitionSupport {
 					}
 
 					ContainerShape targetContainer = FSMSupportUtil.getInstance().getStateGraphContainer((ContainerShape) context.getSourcePictogramElement().eContainer());
-					// hrr: was boolean inherited = FSMSupportUtil.getInstance().isInherited(getDiagram(), sg);
-					// but if we are inside our own refined state it is treated as inherited which is wrong
-					boolean inherited = !EcoreUtil.isAncestor(FSMSupportUtil.getInstance().getModelComponent(getDiagram()), sg);
-					if (inherited) {
-						sg = FSMSupportUtil.getInstance().insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
+					if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+						sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
 					}
 
 					sg.getTransitions().add(trans);
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramEditingUtil.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramEditingUtil.java
new file mode 100644
index 000000000..c90cd2e26
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramEditingUtil.java
@@ -0,0 +1,743 @@
+/*******************************************************************************
+ * Copyright (c) 2011 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.ChoicepointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.EntryPoint;
+import org.eclipse.etrice.core.fsm.fSM.ExitPoint;
+import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+import org.eclipse.etrice.core.fsm.fSM.NonInitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.StateTerminal;
+import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.ContextSwitcher;
+import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider.Pos;
+import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider.PosAndSize;
+import org.eclipse.etrice.ui.behavior.fsm.support.IStateGraphContext;
+import org.eclipse.etrice.ui.behavior.fsm.support.StateGraphSupport;
+import org.eclipse.etrice.ui.behavior.fsm.support.StateSupport;
+import org.eclipse.etrice.ui.behavior.fsm.support.TrPointSupport;
+import org.eclipse.etrice.ui.common.base.support.CommonSupportUtil;
+import org.eclipse.graphiti.datatypes.ILocation;
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.features.IRemoveFeature;
+import org.eclipse.graphiti.features.context.IRemoveContext;
+import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
+import org.eclipse.graphiti.features.context.impl.AddContext;
+import org.eclipse.graphiti.features.context.impl.LayoutContext;
+import org.eclipse.graphiti.features.context.impl.RemoveContext;
+import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
+import org.eclipse.graphiti.mm.algorithms.styles.Point;
+import org.eclipse.graphiti.mm.pictograms.Anchor;
+import org.eclipse.graphiti.mm.pictograms.Connection;
+import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
+import org.eclipse.graphiti.mm.pictograms.ContainerShape;
+import org.eclipse.graphiti.mm.pictograms.Diagram;
+import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.mm.pictograms.Shape;
+import org.eclipse.graphiti.services.Graphiti;
+import org.eclipse.graphiti.services.IGaService;
+import org.eclipse.graphiti.services.ILinkService;
+
+/**
+ *  Shared logic to modify graphical diagram
+ */
+public class DiagramEditingUtil {
+
+	private static final String INITIAL = "init";
+	private static final String STATE = "state:";
+	private static final String TP = "tp:";
+	private static final String CP = "cp:";
+	private static final String SEP = ".";
+	
+	private static DiagramEditingUtil instance = null;
+	
+	public static DiagramEditingUtil getInstance() {
+		if(instance == null)
+			instance = new DiagramEditingUtil();
+		
+		return instance;
+	}
+	
+	public void updateStateGraph(StateGraph sg, IStateGraphContext ctx, ContainerShape sgShape,
+			IFeatureProvider fp) {
+			
+		HashMap<String, Anchor> node2anchor = new HashMap<String, Anchor>();
+		
+		GraphicsAlgorithm borderRect = sgShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
+		ctx.getPositionProvider().setScale(borderRect.getWidth(), borderRect.getHeight());
+		ctx.getPositionProvider().setPosition(sgShape.getGraphicsAlgorithm().getX(), sgShape.getGraphicsAlgorithm().getY());
+		
+		// states
+		{
+			ArrayList<Shape> shapes = new ArrayList<Shape>();
+			List<State> present = getStates(sgShape, fp, node2anchor, shapes);
+			checkDuplicates(present);
+			List<State> expected = ctx.getStates();
+			List<State> toAdd = new ArrayList<State>();
+			List<State> toUpdate = new ArrayList<State>();
+			List<State> toRemove = new ArrayList<State>();
+			for (State item : expected) {
+				if (present.contains(item))
+					toUpdate.add(item);
+				else
+					toAdd.add(item);
+			}
+			for(State item : present){
+				if(!expected.contains(item))
+					toRemove.add(item);
+			}
+	    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+	    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
+	    	removeGraphicalRepresentation(toRemove, shapes, fp);
+		}
+		
+		// transition points
+		{
+			ArrayList<Shape> shapes = new ArrayList<Shape>();
+			List<TrPoint> present = getTrPoints(sg, sgShape, fp, node2anchor, shapes);
+			checkDuplicates(present);
+			List<TrPoint> expected = ctx.getTrPoints();
+			List<TrPoint> toAdd = new ArrayList<TrPoint>();
+			List<TrPoint> toUpdate = new ArrayList<TrPoint>();
+			List<TrPoint> toRemove = new ArrayList<TrPoint>();
+			for (TrPoint item : expected) {
+				if (present.contains(item))
+					toUpdate.add(item);
+				else
+					toAdd.add(item);
+			}
+			for(TrPoint item : present){
+				if(!expected.contains(item))
+					toRemove.add(item);
+			}
+	    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+	    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
+	    	removeGraphicalRepresentation(toRemove, shapes, fp);
+		}
+		
+		// choice points
+		{
+			ArrayList<Shape> shapes = new ArrayList<Shape>();
+			List<ChoicePoint> present = getChoicePoints(sgShape, fp, node2anchor, shapes);
+			checkDuplicates(present);
+			List<ChoicePoint> expected = ctx.getChPoints();
+			List<ChoicePoint> toAdd = new ArrayList<ChoicePoint>();
+			List<ChoicePoint> toUpdate = new ArrayList<ChoicePoint>();
+			List<ChoicePoint> toRemove = new ArrayList<ChoicePoint>();
+			for (ChoicePoint item : expected) {
+				if (present.contains(item))
+					toUpdate.add(item);
+				else
+					toAdd.add(item);
+			}
+			for(ChoicePoint item : present){
+				if(!expected.contains(item))
+					toRemove.add(item);
+			}
+	    	addStateGraphNodes(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+	    	updateStateGraphNodes(toUpdate, shapes, ctx.getPositionProvider(), fp);
+	    	removeGraphicalRepresentation(toRemove, shapes, fp);
+		}
+		
+		getSubTpAnchors(sgShape, node2anchor);
+	
+		// initial point
+		{
+			// exists in this diagram ?
+			Shape present = null;
+			for (Shape ch : sgShape.getChildren()) {
+				Object bo = fp.getBusinessObjectForPictogramElement(ch);
+				if (bo instanceof StateGraph)
+					present = ch;
+			}
+			if(present != null) {
+				node2anchor.put(INITIAL, present.getAnchors().get(0));
+			}
+			// exists in model ?
+			StateGraph expected = ctx.getInitialPoint();
+			if(expected == null) {
+				// exists in (super class) diagram ? 
+				expected = ctx.getPositionProvider().getInitialPoint(ctx.getStateGraph());
+			}
+			if(expected != null && present == null) {
+				addInitialPointIff(ctx, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+			}
+			else {
+				updateInitialPoint(present, ctx.getPositionProvider(), fp);
+			}
+		}
+		
+		// transitions
+		{
+			// get transitions that belong to our state graph
+			// (for other connections we might not have the node anchors yet)
+			Map<Transition, Connection> present = getTransitionsMap(sgShape, fp);
+			List<Transition> expected = ctx.getTransitions();
+			List<Transition> toAdd = new ArrayList<Transition>();
+			List<Transition> toRemove = new ArrayList<Transition>();
+			for (Transition trans : expected)
+				if (!present.containsKey(trans))
+					toAdd.add(trans);
+			for(Transition item : present.keySet()){
+				if(!expected.contains(item))
+					toRemove.add(item);
+			}
+			addTransitions(toAdd, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+			updateTransitions(present, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+			removeGraphicalRepresentation(toRemove, present.values(), fp);
+		}
+	}
+
+
+	public void removeGraphicalRepresentation(Collection<? extends EObject> toRemove, Collection<? extends PictogramElement> pictograms, IFeatureProvider fp) {
+		for(EObject bo : toRemove)
+			for(PictogramElement pe : pictograms)
+				if(fp.getBusinessObjectForPictogramElement(pe) == bo){
+					IRemoveContext rc = new RemoveContext(pe);
+					IRemoveFeature removeFeature = fp.getRemoveFeature(rc);
+					if (removeFeature != null)
+						removeFeature.remove(rc);
+					break;
+				}
+	}
+
+
+	/**
+	 * @param s the state whose sub structure should be deleted
+	 * @param mc the ModelComponent
+	 * @param diagram the current diagram
+	 * @param fp the feature provider
+	 */
+	public void deleteSubStructureRecursive(State s, ModelComponent mc, Diagram diagram, IFeatureProvider fp) {
+		if (FSMSupportUtil.getInstance().getFSMHelpers().hasSubStructure(s, mc)) {
+			StateGraph subgraph = s.getSubgraph();
+			
+			// depth first
+			for (State st : subgraph.getStates()) {
+				deleteSubStructureRecursive(st, mc, diagram, fp);
+			}
+			
+			ContainerShape subShape = ContextSwitcher.getContext(diagram, subgraph);
+			CommonSupportUtil.deleteConnectionsRecursive(subShape, fp);
+			EcoreUtil.delete(subShape, true);
+		}
+	}
+
+	public ContainerShape addStateGraph(IStateGraphContext ctx, Diagram diagram, IFeatureProvider fp) {
+		AddContext addContext = new AddContext();
+		addContext.setNewObject(ctx.getStateGraph());
+		addContext.setTargetContainer(diagram);
+		PosAndSize graphPosAndSize = ctx.getPositionProvider().getGraphPosAndSize(ctx.getStateGraph());
+		if (graphPosAndSize!=null) {
+			addContext.setX(graphPosAndSize.getX());
+			addContext.setY(graphPosAndSize.getY());
+			addContext.setWidth(graphPosAndSize.getWidth());
+			addContext.setHeight(graphPosAndSize.getHeight());
+		}
+		else {
+			addContext.setX(StateGraphSupport.MARGIN);
+			addContext.setY(StateGraphSupport.MARGIN);
+		}
+		
+		ContainerShape sgShape = (ContainerShape) fp.addIfPossible(addContext);
+		if (sgShape==null)
+			return null;
+		
+		final HashMap<String, Anchor> node2anchor = new HashMap<String, Anchor>();
+		
+		GraphicsAlgorithm borderRect = sgShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
+		ctx.getPositionProvider().setScale(borderRect.getWidth(), borderRect.getHeight());
+		ctx.getPositionProvider().setPosition(sgShape.getGraphicsAlgorithm().getX(), sgShape.getGraphicsAlgorithm().getY());
+		
+		addInitialPointIff(ctx, ctx.getPositionProvider(), sgShape, fp, node2anchor);
+		addStateGraphNodes(ctx.getTrPoints(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
+		addStateGraphNodes(ctx.getStates(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
+		addStateGraphNodes(ctx.getChPoints(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
+	
+		for (IStateGraphContext sub : ctx.getChildren()) {
+			addStateGraph(sub, diagram, fp);
+		}
+		
+		getSubTpAnchors(sgShape, node2anchor);
+		
+		addTransitions(ctx.getTransitions(), ctx.getPositionProvider(), sgShape, fp, node2anchor);
+		
+		return sgShape;
+	}
+
+
+	public List<State> getStates(ContainerShape shape, IFeatureProvider fp) {
+		return getStates(shape, fp, null, null);
+	}
+
+	public List<ChoicePoint> getChoicePoints(ContainerShape shape, IFeatureProvider fp) {
+		return getChoicePoints(shape, fp, null, null);
+	}
+
+
+	public List<TrPoint> getTrPoints(StateGraph sg, ContainerShape shape, IFeatureProvider fp) {
+		return getTrPoints(sg, shape, fp, null, null);
+	}
+
+
+	private List<State> getStates(ContainerShape shape, IFeatureProvider fp, Map<String, Anchor> item2anchor, List<Shape> stateShapes) {
+		List<State> items = new ArrayList<State>();
+		for (Shape ch : shape.getChildren()) {
+			Object bo = fp.getBusinessObjectForPictogramElement(ch);
+			if (bo instanceof State) {
+				items.add((State)bo);
+				if (item2anchor!=null)
+					item2anchor.put(getKey((State)bo), ch.getAnchors().get(0));
+				if (stateShapes!=null)
+					stateShapes.add(ch);
+			}
+		}
+		return items;
+	}
+
+	private List<ChoicePoint> getChoicePoints(ContainerShape shape, IFeatureProvider fp, Map<String, Anchor> item2anchor,
+			List<Shape> cpShapes) {
+		List<ChoicePoint> items = new ArrayList<ChoicePoint>();
+		for (Shape ch : shape.getChildren()) {
+			Object bo = fp.getBusinessObjectForPictogramElement(ch);
+			if (bo instanceof ChoicePoint) {
+				items.add((ChoicePoint)bo);
+				if (item2anchor!=null)
+					item2anchor.put(getKey((ChoicePoint)bo), ch.getAnchors().get(0));
+				if (cpShapes!=null)
+					cpShapes.add(ch);
+			}
+		}
+		return items;
+	}
+
+	private List<TrPoint> getTrPoints(StateGraph sg, ContainerShape shape, IFeatureProvider fp,
+			Map<String, Anchor> item2anchor, List<Shape> tpShapes) {
+				List<TrPoint> items = new ArrayList<TrPoint>();
+				for (Shape ch : shape.getChildren()) {
+					Object bo = fp.getBusinessObjectForPictogramElement(ch);
+					if (bo instanceof TrPoint) {
+						items.add((TrPoint)bo);
+						if (item2anchor!=null)
+							item2anchor.put(getKey((TrPoint)bo), ch.getAnchors().get(0));
+						if (tpShapes!=null)
+							tpShapes.add(ch);
+					}
+				}
+				return items;
+			}
+
+	private Map<Transition, Connection> getTransitionsMap(ContainerShape sgShape, IFeatureProvider fp) {
+		Diagram diagram = (Diagram) sgShape.eContainer();
+		Map<Transition, Connection> transitions = new HashMap<Transition, Connection>();
+		for (Connection conn : diagram.getConnections()) {
+			Object bo = fp.getBusinessObjectForPictogramElement(conn);
+			
+			// we only collect connections that have a starting point contained in our sgShape
+			if (bo instanceof Transition && EcoreUtil.isAncestor(sgShape, conn.getStart()))
+				transitions.put((Transition) bo, conn);
+		}
+		return transitions;
+	}
+
+	private void getSubTpAnchors(ContainerShape sgShape, HashMap<String, Anchor> node2anchor) {
+		for (Shape childShape : sgShape.getChildren()) {
+			EObject bo = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(childShape);
+			if (bo instanceof State)
+				getAnchors((State) bo, childShape, node2anchor);
+		}
+	}
+
+	private void addInitialPointIff(IStateGraphContext ctx, IPositionProvider positionProvider, ContainerShape sgShape,
+			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
+			
+		// model
+		StateGraph sg = ctx.getInitialPoint();
+		if(sg==null)
+			// (super class) diagram
+			sg = positionProvider.getInitialPoint(ctx.getStateGraph());
+		if(sg==null)
+			return;
+		
+		PosAndSize pos = positionProvider.getPosition(sg);		
+		AddContext addContext = new AddContext();
+		addContext.setNewObject(sg);
+		addContext.setTargetContainer(sgShape);
+		if(pos != null){
+			addContext.setX(pos.getX());
+			addContext.setY(pos.getY());
+			if (pos.getWidth()>0 && pos.getHeight()>0) {
+				addContext.setWidth(pos.getWidth());
+				addContext.setHeight(pos.getHeight());
+			}
+		} else {
+			addContext.setX(3*StateGraphSupport.MARGIN);
+			addContext.setY(3*StateGraphSupport.MARGIN);
+		}
+		
+		ContainerShape pe = (ContainerShape) fp.addIfPossible(addContext);
+		assert(pe!=null): "initial point should have been created";
+		assert(!pe.getAnchors().isEmpty()): "initial point should have an anchor";
+		node2anchor.put(INITIAL, pe.getAnchors().get(0));
+	}
+
+	private void addTransitions(List<Transition> transitions, IPositionProvider positionProvider, ContainerShape sgShape,
+			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
+			
+		for (Transition trans : transitions) {
+			String from = (trans instanceof InitialTransition)? INITIAL:getKey(((NonInitialTransition)trans).getFrom());
+			String to = getKey(trans.getTo());
+			Anchor src = node2anchor.get(from);
+			Anchor dst = node2anchor.get(to);
+	
+			assert(src!=null && dst!=null): "transition endpoints must be present";
+			
+			AddConnectionContext context = new AddConnectionContext(src, dst);
+			context.setNewObject(trans);
+			PictogramElement pe = fp.addIfPossible(context);
+			if (pe instanceof FreeFormConnection) {
+				FreeFormConnection conn = (FreeFormConnection) pe;
+				
+				// JH: workaround for correct bend points of inherited self transition
+				conn.getBendpoints().clear();
+				
+				List<Pos> points = positionProvider.getPoints(trans);
+				if (points!=null && !points.isEmpty()) {
+					Iterator<Pos> it = points.iterator();
+					
+					// first is label position
+					Pos pos = it.next();
+					ConnectionDecorator cd = conn.getConnectionDecorators().get(1);
+					Graphiti.getGaService().setLocation(cd.getGraphicsAlgorithm(), pos.getX(), pos.getY());
+					
+					// remaining are bend points
+					while (it.hasNext()) {
+						pos = it.next();
+						Point pt = Graphiti.getGaService().createPoint(pos.getX(), pos.getY());
+						conn.getBendpoints().add(pt);
+					}
+				}
+				else if (src==dst) {
+					ILocation begin = Graphiti.getPeService().getLocationRelativeToDiagram(conn.getStart());
+					Point pt = Graphiti.getGaService().createPoint(begin.getX(), begin.getY()+StateGraphSupport.MARGIN*3);
+					conn.getBendpoints().add(pt);
+				}
+			}
+		}
+	}
+	
+	private <T extends StateGraphNode> List<PosAndSize> getPositions(List<T> nodes, IPositionProvider positionProvider, double scaleX) {
+		ArrayList<PosAndSize> result = new ArrayList<PosAndSize>(nodes.size());
+		
+		if (nodes.isEmpty())
+			return result;
+		
+		int n = 0;
+		for (T node : nodes) {
+			PosAndSize pt = positionProvider.getPosition(node);
+			result.add(pt);
+			if (pt==null)
+				n++;
+		}
+
+		int delta = (int) (scaleX / (n+1));
+		int pos = delta;
+		
+		int h = StateGraphSupport.MARGIN;
+		if (nodes.get(0) instanceof State)
+			h = StateGraphSupport.MARGIN + StateGraphSupport.DEFAULT_SIZE_Y/4;
+		else if (nodes.get(0) instanceof ChoicePoint)
+			h = StateGraphSupport.MARGIN + StateGraphSupport.DEFAULT_SIZE_Y/2;
+		else if (nodes.get(0) instanceof TrPoint)
+			h = StateGraphSupport.MARGIN;
+		else {
+			assert(false): "unexpected sub type";
+		}
+		
+		for (int i=0; i<nodes.size(); ++i) {
+			if (result.get(i)==null) {
+				PosAndSize pt = new PosAndSize(
+						pos,
+						h,
+						0,
+						0
+					);
+				result.set(i, pt);
+				
+				pos += delta;
+			}
+		}
+		
+		return result;
+	}
+
+	private void addStateGraphNodes(List<? extends StateGraphNode> nodes, IPositionProvider positionProvider, ContainerShape sgShape,
+			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
+				
+		List<PosAndSize> positions = getPositions(nodes, positionProvider, sgShape.getGraphicsAlgorithm().getWidth());
+		
+		int idx = 0;
+		for (StateGraphNode node : nodes) {
+			addStateGraphNode(node, sgShape, positions.get(idx), fp, node2anchor);
+			++idx;
+		}
+	}
+
+	private void addStateGraphNode(StateGraphNode tp, ContainerShape sgShape, PosAndSize pos,
+			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
+		AddContext addContext = new AddContext();
+		addContext.setNewObject(tp);
+		addContext.setTargetContainer(sgShape);
+		addContext.setX(pos.getX());
+		addContext.setY(pos.getY());
+		if (pos.getWidth()>0 && pos.getHeight()>0) {
+			addContext.setWidth(pos.getWidth());
+			addContext.setHeight(pos.getHeight());
+		}
+		
+		ContainerShape pe = (ContainerShape) fp.addIfPossible(addContext);
+		assert(pe!=null): tp.eClass().getName()+" should have been created";
+		assert(!pe.getAnchors().isEmpty()): tp.eClass().getName()+" should have an anchor";
+		node2anchor.put(getKey(tp), pe.getAnchors().get(0));
+	}
+
+	private void updateInitialPoint(Shape shape, IPositionProvider positionProvider, IFeatureProvider fp) {
+		if (shape==null)
+			return;
+		
+		StateGraph sg = (StateGraph) fp.getBusinessObjectForPictogramElement(shape);
+		PosAndSize ps = positionProvider.getPosition(sg);
+		if (ps==null)
+			return;
+		
+		// relocate and resize the invisible rectangle
+		GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
+	
+		Graphiti.getLayoutService().setLocationAndSize(
+			ga,
+			ps.getX(),
+			ps.getY(),
+			ps.getWidth(),
+			ps.getHeight()
+		);
+		
+		// have to call the layout to adjust the visible border
+		LayoutContext lc = new LayoutContext(shape);
+		fp.layoutIfPossible(lc);
+	}
+
+	private void updateStateGraphNodes(List<? extends StateGraphNode> nodes, List<Shape> shapes, IPositionProvider positionProvider, IFeatureProvider fp) {
+					
+		ILinkService linkService = Graphiti.getLinkService();
+		IGaService gaService = Graphiti.getGaService();
+		
+		for (StateGraphNode node : nodes) {
+			PosAndSize ps = positionProvider.getPosition(node);
+			if (ps==null)
+				continue;
+			
+			// TODO: sub-optimal since quadratic effort - use combined list for nodes and shapes or similar solution
+			for (Shape shape : shapes) {
+				EObject bo = linkService.getBusinessObjectForLinkedPictogramElement(shape);
+				if (bo==node) {
+					// relocate and resize the invisible rectangle
+					GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
+//								System.out.println(node + ": "+ga.getX()+" "+ga.getY()+" "+ga.getWidth()+" "+ga.getHeight());
+//								System.out.println("  -> "+ps.getX()+" "+ps.getY()+" "+ps.getWidth()+" "+ps.getHeight());
+
+					int margin = 0;
+					if (node instanceof State)
+						margin = StateSupport.MARGIN;
+					else if (node instanceof TrPoint)
+						margin = TrPointSupport.MARGIN;
+					
+					gaService.setLocationAndSize(
+							ga,
+							ps.getX()-margin,
+							ps.getY()-margin,
+							ps.getWidth()+2*margin,
+							ps.getHeight()+2*margin
+						);
+					
+					// have to call the layout to adjust the visible border
+					LayoutContext lc = new LayoutContext(shape);
+					fp.layoutIfPossible(lc);
+					
+					// update position of sub items
+					if(shape instanceof ContainerShape){
+						ContainerShape container = (ContainerShape) shape;
+						for(Shape child : container.getChildren()){
+							EObject childBo = linkService.getBusinessObjectForLinkedPictogramElement(child);
+							if(!(childBo instanceof StateGraphNode))
+								continue;
+							
+							double[] relPos = positionProvider.getSubPosition((StateGraphNode) childBo);
+							if(relPos != null)
+								gaService.setLocation(child.getGraphicsAlgorithm(), (int)(relPos[0] * ps.getWidth()), (int)(relPos[1]*ps.getHeight()));
+						}
+					}
+					
+					break;
+				}
+			}
+		}
+	}
+	
+	private void updateTransitions(Map<Transition, Connection> transitions, IPositionProvider positionProvider, ContainerShape sgShape,
+			IFeatureProvider fp, HashMap<String, Anchor> node2anchor) {
+		
+		for(Entry<Transition, Connection> e: transitions.entrySet()){
+			Transition trans = e.getKey();
+			Connection conn = e.getValue();
+			
+			String from = (trans instanceof InitialTransition)? INITIAL:getKey(((NonInitialTransition)trans).getFrom());
+			String to = getKey(trans.getTo());
+			Anchor newSrc = node2anchor.get(from);
+			Anchor newDst = node2anchor.get(to);
+			
+			assert(newSrc!=null && newDst!=null): "transition endpoints must be present";
+			
+			if(conn.getStart()!=newSrc)
+				conn.setStart(newSrc);
+			if(conn.getEnd()!=newDst)
+				conn.setEnd(newDst);			
+			
+			List<Pos> points = positionProvider.getPoints(trans);
+			Iterator<Pos> it = points.iterator();
+			if (points==null || points.isEmpty())
+				continue;
+			
+			// first is label position
+			Pos pos = it.next();
+			ConnectionDecorator cd = conn.getConnectionDecorators().get(1);
+			Graphiti.getGaService().setLocation(cd.getGraphicsAlgorithm(), pos.getX(), pos.getY());
+			
+			if (conn instanceof FreeFormConnection) {
+				FreeFormConnection fconn = (FreeFormConnection) conn;
+	
+				// remaining are bend points
+				fconn.getBendpoints().clear();
+				List<Point> bendpoints = new ArrayList<Point>();
+				while (it.hasNext()) {
+					pos = it.next();
+					Point pt = Graphiti.getGaService().createPoint(pos.getX(), pos.getY());
+					bendpoints.add(pt);
+				}
+				fconn.getBendpoints().addAll(bendpoints);
+			}
+		}
+	}
+	
+	private void getAnchors(State state, PictogramElement stateShape, final HashMap<String, Anchor> node2anchor) {		
+		if (stateShape instanceof ContainerShape) {
+			node2anchor.put(getKey(state), ((ContainerShape)stateShape).getAnchors().get(0));
+			for (Shape child : ((ContainerShape) stateShape).getChildren()) {
+				if (child instanceof ContainerShape) {
+					ContainerShape childShape = (ContainerShape) child;
+					if (!childShape.getAnchors().isEmpty()) {
+						if (!childShape.getLink().getBusinessObjects().isEmpty()) {
+							EObject obj = childShape.getLink().getBusinessObjects().get(0);
+							if (obj instanceof EntryPoint || obj instanceof ExitPoint) {
+								node2anchor.put(getKey(obj, true), childShape.getAnchors().get(0));
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	private String getKey(EObject obj) {
+		return getKey(obj, false);
+	}
+
+	private String getKey(EObject obj, boolean subTp) {
+		if (obj instanceof TrPoint) {
+			TrPoint tp = (TrPoint) obj;
+			if (!subTp)
+				return TP+tp.getName();
+			else {
+				if (tp.eContainer().eContainer() instanceof State) {
+					State s = (State) tp.eContainer().eContainer();
+					return TP+tp.getName()+SEP+s.getName();
+				}
+				else {
+					assert(false): "State expected";
+				}
+			}
+		}
+		else if (obj instanceof State) {
+			return STATE+((State)obj).getName();
+		}
+		else if (obj instanceof ChoicePoint) {
+			return CP+((ChoicePoint)obj).getName();
+		}
+		else if (obj instanceof TransitionTerminal) {
+			TransitionTerminal tt = (TransitionTerminal) obj;
+			if (tt instanceof ChoicepointTerminal) {
+				return CP+((ChoicepointTerminal)tt).getCp().getName();
+			}
+			else if (tt instanceof StateTerminal) {
+				return STATE+((StateTerminal)tt).getState().getName();
+			}
+			else if (tt instanceof SubStateTrPointTerminal) {
+				SubStateTrPointTerminal sstt = (SubStateTrPointTerminal) tt;
+				return TP+sstt.getTrPoint().getName()+SEP+sstt.getState().getName();
+			}
+			else if (tt instanceof TrPointTerminal) {
+				return TP+((TrPointTerminal)tt).getTrPoint().getName();
+			}
+			else {
+				assert(false): "unexpected sub type";
+			}
+		}
+		assert(false): "unexpected type";
+		return null;
+	}
+	
+
+	private void checkDuplicates(List<? extends StateGraphItem> items) {
+		FSMNameProvider fsmNameProvider = FSMSupportUtil.getInstance().getFSMNameProvider();
+		for (StateGraphItem item : items) {
+			if (items.indexOf(item)!=items.lastIndexOf(item)) {
+				Assert.isTrue(
+						items.indexOf(item)==items.lastIndexOf(item),
+						"multiple occurrences of "+fsmNameProvider.getFullPath(item));
+			}
+		}
+	}
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.xtend
new file mode 100644
index 000000000..6905d6821
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.xtend
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support.util
+
+import org.eclipse.graphiti.mm.pictograms.PictogramElement
+import org.eclipse.graphiti.services.Graphiti
+import org.eclipse.graphiti.features.context.IPictogramElementContext
+import org.eclipse.emf.ecore.EObject
+
+class DiagramExtensions {
+	
+	def static <T extends PictogramElement> getCastedPe(IPictogramElementContext ctx){
+		ctx.pictogramElement as T
+	}
+	
+	def static <T extends EObject> getCastedBo(PictogramElement pe) {
+		Graphiti.linkService.getBusinessObjectForLinkedPictogramElement(pe) as T
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/FSMSupportUtil.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/FSMSupportUtil.java
new file mode 100644
index 000000000..d283a8b1a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/FSMSupportUtil.java
@@ -0,0 +1,271 @@
+/*******************************************************************************
+ * Copyright (c) 2014 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.ChoicepointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.FSMFactory;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+import org.eclipse.etrice.core.fsm.fSM.RefinedState;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraph;
+import org.eclipse.etrice.core.fsm.fSM.StateTerminal;
+import org.eclipse.etrice.core.fsm.fSM.SubStateTrPointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.fsm.fSM.TrPointTerminal;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionTerminal;
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
+import org.eclipse.etrice.core.fsm.ui.FSMUiModule;
+import org.eclipse.etrice.core.fsm.util.FSMHelpers;
+import org.eclipse.etrice.core.fsm.util.FSMNewNamingUtil;
+import org.eclipse.etrice.core.fsm.validation.FSMValidationUtil;
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
+import org.eclipse.graphiti.mm.pictograms.Anchor;
+import org.eclipse.graphiti.mm.pictograms.Connection;
+import org.eclipse.graphiti.mm.pictograms.ContainerShape;
+import org.eclipse.graphiti.mm.pictograms.Diagram;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.services.Graphiti;
+
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+
+/**
+ *  Shared business logic, side-effect free util methods
+ */
+public class FSMSupportUtil {
+
+
+	private static FSMSupportUtil instance = null;
+
+	/**
+	 * @return the instance
+	 */
+	public static FSMSupportUtil getInstance() {
+		if (instance==null) {
+			// this class has members that have to be filled by the FSMUi injector
+			Injector injector = FSMUiModule.getInjector();
+	        instance = injector.getInstance(FSMSupportUtil.class);
+		}
+		return instance;
+	}
+
+	@Inject
+	private FSMHelpers fsmHelpers;
+	@Inject
+	private FSMValidationUtil fsmValidationUtil;
+	@Inject
+	private FSMNameProvider fsmNameProvider;
+	@Inject
+	private FSMNewNamingUtil fsmNewNamingUtil;
+
+	/**
+	 * @return the roomHelpers
+	 */
+	public FSMHelpers getFSMHelpers() {
+		return fsmHelpers;
+	}
+
+	/**
+	 * @return the validationUtil
+	 */
+	public FSMValidationUtil getFSMValidationUtil() {
+		return fsmValidationUtil;
+	}
+
+	/**
+	 * @return the roomUtil
+	 */
+	public FSMNewNamingUtil getFSMNewNamingUtil() {
+		return fsmNewNamingUtil;
+	}
+
+	/**
+	 * @return the roomNameProvider
+	 */
+	public FSMNameProvider getFSMNameProvider() {
+		return fsmNameProvider;
+	}
+
+	public boolean isInherited(Diagram diag, EObject obj) {
+		return isInherited(getModelComponent(diag), obj);
+	}
+	
+	public boolean isInherited(ModelComponent mc, EObject obj) {
+		if (obj instanceof StateGraph)
+			obj = obj.eContainer();
+		else if (obj instanceof ModelComponent)
+			// the next line states: if a ModelComponent has no base class, then it is not inherited.
+			// And vice versa: if it has a base class it is inherited
+			// QUESTION: is this correct?
+			// However, this method isn't called with an obj instanceof ModelComponent
+			return ((ModelComponent) obj).getBase() != null;
+		
+		return  obj instanceof RefinedState || obj instanceof RefinedTransition || !EcoreUtil.isAncestor(mc, obj);
+	}
+	
+	public boolean isOwnedBy(Diagram diag, EObject obj) {
+		return isOwnedBy(getModelComponent(diag), obj);
+	}
+	
+	public boolean isOwnedBy(ModelComponent mc, EObject obj) {
+		return EcoreUtil.isAncestor(mc, obj);
+	}
+
+	public boolean showAsInherited(Diagram diag, State obj) {
+	
+		if (obj instanceof RefinedState)
+			return true;
+	
+		return fsmHelpers.getModelComponent(obj)!=getModelComponent(diag);
+	}
+
+	public Diagram getDiagram(GraphicsAlgorithm ga) {
+		if (ga.eContainer() instanceof GraphicsAlgorithm)
+			return getDiagram((GraphicsAlgorithm)ga.eContainer());
+		return getDiagram(ga.getPictogramElement());
+	}
+
+	public Diagram getDiagram(PictogramElement pe) {
+		while (pe.eContainer()!=null) {
+			if (pe.eContainer() instanceof Diagram)
+				return (Diagram) pe.eContainer();
+			pe = (PictogramElement) pe.eContainer();
+		}
+		return null;
+	}
+
+	public ModelComponent getModelComponent(Diagram diag) {
+		EObject bo = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(diag);
+		if (bo instanceof ModelComponent)
+			return (ModelComponent) bo;
+		return null;
+	}
+
+	public State getTargettingState(State state, Diagram diagram) {
+		ModelComponent mc = getModelComponent(diagram);
+		return fsmHelpers.getTargettingState(state, mc);
+	}
+
+	/**
+	 * This method exploits the fact that the immediate children of the diagram are
+	 * associated with the state graphs.
+	 * 
+	 * @param shape
+	 * @return the container shape that is associated with the state graph of the diagram
+	 */
+	public ContainerShape getStateGraphContainer(ContainerShape shape) {
+		while (shape!=null) {
+			ContainerShape parent = shape.getContainer();
+			if (parent instanceof Diagram)
+				return shape;
+			shape = parent;
+		}
+		return null;
+	}
+
+	public StateGraph getStateGraph(ContainerShape cs, IFeatureProvider fp) {
+		ContainerShape shape = getStateGraphContainer(cs);
+		Object bo = fp.getBusinessObjectForPictogramElement(shape);
+		if (bo instanceof StateGraph)
+			return (StateGraph) bo;
+		else
+			assert(false): "state graph expected";
+			
+		return null;
+	}
+
+	public TransitionTerminal getTransitionTerminal(Anchor anchor, IFeatureProvider fp) {
+		if (anchor != null) {
+			Object obj = fp.getBusinessObjectForPictogramElement(anchor.getParent());
+			if (obj instanceof TrPoint) {
+				Object parent = fp.getBusinessObjectForPictogramElement((ContainerShape) anchor.getParent().eContainer());
+				if (parent instanceof State) {
+					State state = (parent instanceof RefinedState)? ((RefinedState)parent).getTarget() : (State)parent;
+					SubStateTrPointTerminal sstpt = FSMFactory.eINSTANCE.createSubStateTrPointTerminal();
+					sstpt.setState(state);
+					sstpt.setTrPoint((TrPoint) obj);
+					return sstpt;
+				}
+				else {
+					TrPointTerminal tpt = FSMFactory.eINSTANCE.createTrPointTerminal();
+					tpt.setTrPoint((TrPoint) obj);
+					return tpt;
+				}
+			}
+			else if (obj instanceof State) {
+				State state = (obj instanceof RefinedState)? ((RefinedState)obj).getTarget() : (State)obj;
+				StateTerminal st = FSMFactory.eINSTANCE.createStateTerminal();
+				st.setState(state);
+				return st;
+			}
+			else if (obj instanceof ChoicePoint) {
+				ChoicepointTerminal ct = FSMFactory.eINSTANCE.createChoicepointTerminal();
+				ct.setCp((ChoicePoint) obj);
+				return ct;
+			}
+		}
+		return null;
+	}
+
+	public boolean isInitialPoint(Anchor anchor, IFeatureProvider fp) {
+		if (anchor!=null) {
+			Object obj = fp.getBusinessObjectForPictogramElement(anchor.getParent());
+			if (obj instanceof StateGraph) {
+				Object parent = fp.getBusinessObjectForPictogramElement((ContainerShape) anchor.getParent().eContainer());
+				if (parent instanceof StateGraph)
+					return true;
+			}
+		}
+		return false;
+	}
+
+	public boolean canConnect(Anchor asrc, Anchor atgt, ContainerShape cs, IFeatureProvider fp) {
+		return canConnect(asrc, atgt, null, cs, fp);
+	}
+
+	public boolean canConnect(Anchor asrc, Anchor atgt, Transition trans, ContainerShape cs, IFeatureProvider fp) {
+		TransitionTerminal src = getTransitionTerminal(asrc, fp);
+		TransitionTerminal tgt = getTransitionTerminal(atgt, fp);
+		
+		if (src==null && !isInitialPoint(asrc, fp))
+			return false;
+		if (tgt==null)
+			return false;
+		
+		StateGraph sg = getStateGraph(cs, fp);
+		if (sg==null)
+			return false;
+		
+		return fsmValidationUtil.isConnectable(src, tgt, trans, sg).isOk();
+	}
+
+	public List<Transition> getTransitions(Diagram diagram, IFeatureProvider fp) {
+		List<Transition> transitions = new ArrayList<Transition>();
+		for (Connection conn : diagram.getConnections()) {
+			Object bo = fp.getBusinessObjectForPictogramElement(conn);
+			if (bo instanceof Transition)
+				transitions.add((Transition) bo);
+		}
+		return transitions;
+	}
+
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.xtend b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.xtend
new file mode 100644
index 000000000..357f254e6
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.xtend
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * CONTRIBUTORS:
+ * 		Juergen Haug (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.ui.behavior.fsm.support.util
+
+import java.util.HashMap
+import org.eclipse.etrice.core.fsm.fSM.FSMFactory
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent
+import org.eclipse.etrice.core.fsm.fSM.RefinedState
+import org.eclipse.etrice.core.fsm.fSM.State
+import org.eclipse.etrice.core.fsm.fSM.StateGraph
+import org.eclipse.graphiti.features.IFeatureProvider
+import org.eclipse.graphiti.mm.pictograms.ContainerShape
+
+/**
+ *  Shared model editing
+ */
+class ModelEditingUtil {
+	
+	def static public RefinedState getOrCreateRefinedStateFor(State s, ModelComponent mc) {
+		val target2rs = new HashMap<State, RefinedState>();
+		for (State st : mc.getStateMachine().getStates()) {
+			if (st instanceof RefinedState)
+				target2rs.put((st as RefinedState).getTarget(), st as RefinedState);
+		}
+		
+		var RefinedState rs = null;
+		
+		// do we already have a RefinedState pointing to s?
+		if (target2rs.containsKey(s)) {
+			rs = target2rs.get(s);
+		}
+		else {
+			// we have to create one and place it in the best fitting context
+			var StateGraph sg = null;
+			var State parent = s;
+			var break = false;
+			while (parent.eContainer().eContainer() instanceof State && !break) {
+				parent =  s.eContainer().eContainer() as State;
+				if (target2rs.containsKey(parent)) {
+					val bestFitting = target2rs.get(parent);
+					if (bestFitting.getSubgraph()===null)
+						bestFitting.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
+					sg = bestFitting.getSubgraph();
+					break = true;
+				}
+			}
+			
+			if (sg===null)
+				sg = mc.getStateMachine();
+			
+			rs = FSMFactory.eINSTANCE.createRefinedState();
+			rs.setTarget(s);
+			sg.getStates().add(rs);
+		}
+		return rs;
+	}
+	
+	
+	
+	def static public StateGraph getOrCreateSubGraphOfRefinedStateFor(State s, ModelComponent mc) {
+		val rs = getOrCreateRefinedStateFor(s, mc);
+		
+		if (rs.getSubgraph()===null)
+			rs.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
+	
+		return rs.getSubgraph();
+	}
+	
+	def static public StateGraph insertRefinedState(StateGraph sg, ModelComponent mc, ContainerShape targetContainer, IFeatureProvider fp) {
+		val sg2 = getOrCreateSubGraphOfRefinedStateFor(sg.eContainer() as State, mc);
+		fp.link(targetContainer, sg2);
+		return sg2;
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.ui.behavior/.classpath b/plugins/org.eclipse.etrice.ui.behavior/.classpath
index 1fa3e6803..eca7bdba8 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/.classpath
+++ b/plugins/org.eclipse.etrice.ui.behavior/.classpath
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="output" path="bin"/>
diff --git a/plugins/org.eclipse.etrice.ui.behavior/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.ui.behavior/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..0c68a61dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/plugins/org.eclipse.etrice.ui.behavior/META-INF/MANIFEST.MF b/plugins/org.eclipse.etrice.ui.behavior/META-INF/MANIFEST.MF
index 36aa40a48..a21837d01 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.etrice.ui.behavior/META-INF/MANIFEST.MF
@@ -21,7 +21,8 @@ Require-Bundle: org.eclipse.etrice.core.room.ui;bundle-version="1.1.3",
  org.eclipse.xtext.ui.shared;bundle-version="2.6.0",
  org.eclipse.etrice.abstractexec.behavior;bundle-version="1.1.3",
  org.eclipse.etrice.core.genmodel;bundle-version="1.1.3",
- org.eclipse.etrice.expressions.ui;bundle-version="1.1.3"
+ org.eclipse.etrice.expressions.ui;bundle-version="1.1.3",
+ org.eclipse.etrice.generator;bundle-version="1.1.3"
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-Vendor: Eclipse eTrice
diff --git a/plugins/org.eclipse.etrice.ui.behavior/build.properties b/plugins/org.eclipse.etrice.ui.behavior/build.properties
index c59c976d4..6c480f39f 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/build.properties
+++ b/plugins/org.eclipse.etrice.ui.behavior/build.properties
@@ -1,5 +1,4 @@
-source.. = src/,\
-			xtend-gen/
+source.. = src/
 output.. = bin/
 bin.includes = META-INF/,\
                .,\
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java
index ed876868c..9e1d304fa 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java
@@ -21,12 +21,9 @@ import org.eclipse.etrice.core.room.RoomModel;
 import org.eclipse.etrice.ui.behavior.editor.BehaviorEditor;
 import org.eclipse.etrice.ui.behavior.fsm.commands.PopulateDiagramCommand;
 import org.eclipse.etrice.ui.behavior.fsm.editor.BehaviorExporter;
-import org.eclipse.etrice.ui.behavior.fsm.support.DiagramUpdateFeature;
 import org.eclipse.etrice.ui.common.base.commands.UpdateCommand;
 import org.eclipse.etrice.ui.common.base.export.IBulkDiagramExporter;
 import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase;
-import org.eclipse.graphiti.dt.IDiagramTypeProvider;
-import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.ui.services.GraphitiUi;
 
@@ -92,7 +89,7 @@ public class DiagramAccess extends DiagramAccessBase {
 	@Override
 	protected Command getInitialCommand(EObject rootObject, Diagram diagram, TransactionalEditingDomain editingDomain) {
 		if (rootObject instanceof ModelComponent) {
-			return new PopulateDiagramCommand("org.eclipse.etrice.ui.behavior.diagramTypeProvider", diagram, (ModelComponent) rootObject, Activator.getDefault().getInjector(), editingDomain);
+			return new PopulateDiagramCommand(DiagramTypeProvider.PROVIDER_ID, diagram, (ModelComponent) rootObject, editingDomain);
 		}
 		return null;
 	}
@@ -102,9 +99,8 @@ public class DiagramAccess extends DiagramAccessBase {
 	 */
 	@Override
 	protected Command getUpdateCommand(Diagram diagram, TransactionalEditingDomain editingDomain) {
-		IDiagramTypeProvider dtp = GraphitiUi.getExtensionManager().createDiagramTypeProvider(diagram, DiagramTypeProvider.PROVIDER_ID); //$NON-NLS-1$
-		IFeatureProvider featureProvider = dtp.getFeatureProvider();
-		UpdateCommand cmd = new UpdateCommand(diagram, editingDomain, new DiagramUpdateFeature(featureProvider));
+		GraphitiUi.getExtensionManager().createDiagramTypeProvider(diagram, DiagramTypeProvider.PROVIDER_ID);
+		UpdateCommand cmd = new UpdateCommand(DiagramTypeProvider.PROVIDER_ID, diagram, editingDomain);
 		if (cmd.updateNeeded())
 			return cmd;
 		
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramTypeProvider.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramTypeProvider.java
index 1af861f41..3e23e2fe0 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramTypeProvider.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramTypeProvider.java
@@ -14,10 +14,11 @@ package org.eclipse.etrice.ui.behavior;
 
 import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider;
 import org.eclipse.etrice.ui.behavior.fsm.support.AbstractFSMProviderDispatcher;
-import org.eclipse.etrice.ui.behavior.support.ProviderDispatcher;
 import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase;
 import org.eclipse.graphiti.tb.IToolBehaviorProvider;
 
+import com.google.inject.Injector;
+
 public class DiagramTypeProvider extends AbstractFSMDiagramTypeProvider {
 
 	public static final String PROVIDER_ID = "org.eclipse.etrice.ui.behavior.diagramTypeProvider";
@@ -29,7 +30,7 @@ public class DiagramTypeProvider extends AbstractFSMDiagramTypeProvider {
 
 	public DiagramTypeProvider() {
 		super();
-		dispatcher = new ProviderDispatcher(this);
+		dispatcher = new AbstractFSMProviderDispatcher(this);
 		setFeatureProvider(dispatcher.getFeatureProvider());
 	}
 
@@ -66,6 +67,11 @@ public class DiagramTypeProvider extends AbstractFSMDiagramTypeProvider {
 	public boolean isAutoUpdateAtRuntime() {
 		return USE_AUTO_UPDATE;
 	}
+	
+	@Override
+	public Injector getInjector() {
+		return Activator.getDefault().getInjector();
+	}
 
 	@Override
 	public DiagramAccessBase getDiagramAccess() {
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/PortMessageSelectionDialog.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/PortMessageSelectionDialog.java
index e7409033c..70fe879df 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/PortMessageSelectionDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/PortMessageSelectionDialog.java
@@ -25,6 +25,7 @@ import org.eclipse.etrice.core.room.PortClass;
 import org.eclipse.etrice.core.room.PortOperation;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 import org.eclipse.etrice.core.ui.RoomUiModule;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
 import org.eclipse.etrice.ui.behavior.Activator;
 import org.eclipse.etrice.ui.behavior.fsm.dialogs.ISelectionDialog;
 import org.eclipse.etrice.ui.behavior.support.SupportUtil;
@@ -221,7 +222,7 @@ public class PortMessageSelectionDialog extends FormDialog implements ISelection
 				if (element instanceof MsgItemPair) {
 					Message msg = ((MsgItemPair) element).msg;
 					if (msg.getData()!=null)
-						return msg.getData().getName()+" : "+msg.getData().getRefType().getType().getName();
+						return msg.getData().getRefType().getType().getName();
 				}
 				else if (element instanceof OperationItemPair) {
 					String sig = SupportUtil.getInstance().getRoomNameProvider().getTypedArgumentList(((OperationItemPair) element).op);
@@ -329,7 +330,7 @@ public class PortMessageSelectionDialog extends FormDialog implements ISelection
 			if (element instanceof MsgItemPair) {
 				MsgItemPair pair = (MsgItemPair) element;
 				if (pair.out) {
-					String data = pair.msg.getData()!=null? pair.msg.getData().getName() : "";
+					String data = pair.msg.getData()!=null? ILanguageExtension.GENERIC_DATA_NAME : "";
 					String index = "";
 					if (pair.item instanceof Port && ((Port)pair.item).getMultiplicity()!=1)
 						index = "[idx]";
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/StatePropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/StatePropertyDialog.java
index 85b1d25df..25689df7e 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/StatePropertyDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/StatePropertyDialog.java
@@ -1,6 +1,11 @@
 package org.eclipse.etrice.ui.behavior.dialogs;
 
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.STATE__DO_CODE;
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.STATE__ENTRY_CODE;
+import static org.eclipse.etrice.core.ui.util.UIExpressionUtil.getExpressionProvider;
+
 import java.util.EnumSet;
+import java.util.List;
 
 import org.eclipse.core.databinding.DataBindingContext;
 import org.eclipse.core.databinding.validation.IValidator;
@@ -17,7 +22,7 @@ import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.validation.FSMValidationUtilXtend.Result;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
-import org.eclipse.etrice.expressions.detailcode.RuntimeDetailExpressionProvider;
+import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider;
 import org.eclipse.etrice.ui.behavior.Activator;
 import org.eclipse.etrice.ui.behavior.fsm.actioneditor.IActionCodeEditor;
 import org.eclipse.etrice.ui.behavior.fsm.dialogs.AbstractMemberAwarePropertyDialog;
@@ -26,6 +31,7 @@ import org.eclipse.etrice.ui.behavior.fsm.dialogs.IStatePropertyDialog;
 import org.eclipse.etrice.ui.behavior.fsm.dialogs.QuickFixDialog;
 import org.eclipse.etrice.ui.behavior.fsm.dialogs.StringToDetailCode;
 import org.eclipse.etrice.ui.behavior.support.SupportUtil;
+import org.eclipse.etrice.ui.common.base.dialogs.MultiValidator2;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.layout.GridData;
@@ -37,7 +43,7 @@ import org.eclipse.ui.forms.IManagedForm;
 
 public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog implements IStatePropertyDialog {
 
-	class NameValidator implements IValidator {
+	private class NameValidator implements IValidator {
 
 		@Override
 		public IStatus validate(Object value) {
@@ -51,8 +57,37 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 			return Status.OK_STATUS;
 		}
 	}
+	
+	private class NonEmptyRefinedStateValidator extends MultiValidator2 {
+		
+		public NonEmptyRefinedStateValidator(DataBindingContext bindingContext, int nActionCodes) {
+			super(bindingContext, nActionCodes);
+		}
+		
+		@Override
+		public IStatus validate(List<Object> values) {
+			if (state instanceof RefinedState) {
+				RefinedState rs = (RefinedState) state;
+				if (rs.getSubgraph()==null) {
+					RoomHelpers roomHelpers = SupportUtil.getInstance().getRoomHelpers();
+					boolean allEmpty = true;
+					for (Object value : values) {
+						String actionCode = roomHelpers.getDetailCode((DetailCode) value);
+						if (!actionCode.trim().isEmpty()) {
+							allEmpty = false;
+							break;
+						}
+					}
+					if (allEmpty) {
+						return ValidationStatus.error("Not all action codes must be empty if the refined state has no subgraph.");
+					}
+				}
+			}
+			return ValidationStatus.ok();
+		}
+		
+	}
 
-	private ActorClass ac;
 	private State state;
 	private boolean inherited;
 
@@ -75,7 +110,6 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 
 	public StatePropertyDialog(Shell shell, ActorClass ac, State s, boolean edit) {
 		super(shell, edit?"Edit State":"View State", ac);
-		this.ac = ac;
 		this.state = s;
 
 		Activator.getDefault().getInjector().injectMembers(this);
@@ -114,6 +148,11 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 		StringToDetailCode s2m = new StringToDetailCode();
 		
 		RoomHelpers roomHelpers = SupportUtil.getInstance().getRoomHelpers();
+		ActorClass ac = roomHelpers.getActorClass(state);
+		boolean hasDoCode = ac.getCommType()!=ComponentCommunicationType.EVENT_DRIVEN;
+		
+		int nActionCodes = hasDoCode ? 3 : 2;
+		NonEmptyRefinedStateValidator nonEmptyValidator = new NonEmptyRefinedStateValidator(bindingContext, nActionCodes);
 		
 		if (inherited) {
 			String code = roomHelpers.getDetailCode(state.getEntryCode());
@@ -140,8 +179,8 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 				}
 			}
 
-			createActionCodeEditor(body, "&Entry Code:", state.getEntryCode(),
-					FSMPackage.eINSTANCE.getState_EntryCode(), s2m, m2s);
+			createActionCodeEditor(body, "&Entry Code:", state.getEntryCode(), FSMPackage.eINSTANCE.getState_EntryCode(), nonEmptyValidator, s2m,
+					m2s, getExpressionProvider(state, STATE__ENTRY_CODE));
 		}
 
 		if (inherited) {
@@ -154,8 +193,8 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 			entry.setLayoutData(gd);
 		}
 		else {
-			createActionCodeEditor(body, "E&xit Code:", state.getExitCode(),
-					FSMPackage.eINSTANCE.getState_ExitCode(), s2m, m2s);
+			createActionCodeEditor(body, "E&xit Code:", state.getExitCode(), FSMPackage.eINSTANCE.getState_ExitCode(), nonEmptyValidator, s2m,
+					m2s, getExpressionProvider(state, STATE__ENTRY_CODE));
 
 			if (state instanceof RefinedState)
 			{
@@ -167,10 +206,9 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 			}
 		}
 
-		ActorClass ac = roomHelpers.getActorClass(state);
-		if (ac.getCommType()!=ComponentCommunicationType.EVENT_DRIVEN)
-			createActionCodeEditor(body, "&Do Code:", state.getDoCode(),
-					FSMPackage.eINSTANCE.getState_DoCode(), s2m, m2s);
+		if (hasDoCode)
+			createActionCodeEditor(body, "&Do Code:", state.getDoCode(), FSMPackage.eINSTANCE.getState_DoCode(), nonEmptyValidator, s2m,
+					m2s, getExpressionProvider(state, STATE__DO_CODE));
 
 		createMembersAndMessagesButtons(body);
 
@@ -189,7 +227,6 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 	 * {@link #state} and binds it with the model.
 	 * 
 	 * @author jayant
-	 * 
 	 * @param parent
 	 *            the {@link Composite} which will hold the editor
 	 * @param label
@@ -198,20 +235,20 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 	 *            the {@link DetailCode} object to be represented
 	 * @param feat
 	 *            the {@link EStructuralFeature} associated with the code
+	 * @param multiValidator 
 	 * @param s2m
 	 *            a String to Model converter
 	 * @param m2s
 	 *            a Model to string converter
-	 * 
 	 * @return the constructed instance of {@link IActionCodeEditor}
 	 */
-	private void createActionCodeEditor(Composite parent, String label,
-			DetailCode detailCode, EStructuralFeature feat,
-			StringToDetailCode s2m, DetailCodeToString m2s) {
-
+	private void createActionCodeEditor(Composite parent, String label, DetailCode detailCode, EStructuralFeature feat,
+			MultiValidator2 multiValidator, StringToDetailCode s2m, DetailCodeToString m2s,
+			IDetailExpressionProvider detailExpr) {
+		
 		IActionCodeEditor entry = super.createActionCodeEditor(parent, label,
-				detailCode, state, feat, s2m, m2s, new RuntimeDetailExpressionProvider(ac));
-
+				detailCode, state, feat, null, multiValidator, s2m, m2s, true, true, false, detailExpr);
+		
 		Control control;
 		if (entry != null)
 			control = entry.getControl();
@@ -223,6 +260,7 @@ public class StatePropertyDialog extends AbstractMemberAwarePropertyDialog imple
 			configureMemberAwareness(textEntry, true, true);
 			control = textEntry;
 		}
+		createDecorator(control, "invalid text");
 
 		//set layout for the created control
 		GridData gd = new GridData(GridData.FILL_BOTH);
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/TransitionPropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/TransitionPropertyDialog.java
index 8099be8b6..2108cfb8e 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/TransitionPropertyDialog.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/TransitionPropertyDialog.java
@@ -1,5 +1,10 @@
 package org.eclipse.etrice.ui.behavior.dialogs;
 
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.CP_BRANCH_TRANSITION__CONDITION;
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.GUARDED_TRANSITION__GUARD;
+import static org.eclipse.etrice.core.fsm.fSM.FSMPackage.Literals.TRANSITION_BASE__ACTION;
+import static org.eclipse.etrice.core.ui.util.UIExpressionUtil.getExpressionProvider;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -22,19 +27,12 @@ import org.eclipse.etrice.core.fsm.fSM.Transition;
 import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
 import org.eclipse.etrice.core.fsm.util.FSMHelpers;
 import org.eclipse.etrice.core.fsm.validation.FSMValidationUtilXtend.Result;
-import org.eclipse.etrice.core.genmodel.builder.GeneratorModelBuilder;
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullDiagnostician;
-import org.eclipse.etrice.core.genmodel.fsm.base.NullLogger;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.CommunicationType;
 import org.eclipse.etrice.core.room.InterfaceItem;
 import org.eclipse.etrice.core.room.ProtocolClass;
-import org.eclipse.etrice.core.room.VarDecl;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
-import org.eclipse.etrice.expressions.detailcode.GuardDetailExpressionProvider;
 import org.eclipse.etrice.expressions.detailcode.IDetailExpressionProvider;
-import org.eclipse.etrice.expressions.detailcode.RuntimeDetailExpressionProvider;
 import org.eclipse.etrice.ui.behavior.Activator;
 import org.eclipse.etrice.ui.behavior.fsm.actioneditor.IActionCodeEditor;
 import org.eclipse.etrice.ui.behavior.fsm.dialogs.AbstractMemberAwarePropertyDialog;
@@ -99,7 +97,9 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 		}
 	}
 	
+	@SuppressWarnings("unused")
 	private ActorClass ac;
+	
 	private Transition trans;
 	private List<AbstractInterfaceItem> interfaceItems = new ArrayList<AbstractInterfaceItem>();
 	private DetailCodeToString m2s;
@@ -185,11 +185,6 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 		}
 		
 		FSMHelpers fsmHelpers = SupportUtil.getInstance().getFSMHelpers();
-
-		VarDecl transitionEventData = null;
-		ExpandedActorClass xpac = new GeneratorModelBuilder(new NullLogger(), new NullDiagnostician()).createExpandedActorClass(ac);
-		if(xpac != null && xpac.getCopy(trans) instanceof Transition)
-			transitionEventData = xpac.getVarDeclData((Transition) xpac.getCopy(trans));
 		
 		if (trans instanceof GuardedTransition) {
 			GuardedTransition guardedTrans = (GuardedTransition) trans;
@@ -199,14 +194,12 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 			}
 			else {
 				GuardValidator gv = new GuardValidator("guard must not be empty");
-				GuardDetailExpressionProvider exprProvider = new GuardDetailExpressionProvider(ac);
-				exprProvider.setTransitionEventData(transitionEventData);
 		
 				createActionCodeEditor(body, "&Guard:", guardedTrans.getGuard(),
 						trans,
 						FSMPackage.eINSTANCE.getGuardedTransition_Guard(), gv,
 						s2m_not_null, m2s_null_empty, true, true, true,
-						"empty guard", exprProvider);
+						"empty guard", getExpressionProvider(guardedTrans, GUARDED_TRANSITION__GUARD));
 			}
 		}
 		
@@ -217,8 +210,6 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 			}
 			else {
 				GuardValidator gv = new GuardValidator("condition must not be empty");
-				GuardDetailExpressionProvider exprProvider = new GuardDetailExpressionProvider(ac);
-				exprProvider.setTransitionEventData(transitionEventData);
 
 				createActionCodeEditor(
 						body,
@@ -227,7 +218,7 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 						trans,
 						FSMPackage.eINSTANCE.getCPBranchTransition_Condition(),
 						gv, s2m_not_null, m2s_null_empty, true, true, true,
-						"empty condition", exprProvider);
+						"empty condition", getExpressionProvider(trans, CP_BRANCH_TRANSITION__CONDITION));
 			}
 		}
 
@@ -238,23 +229,20 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 				setTextSelectionAndFocus(baseActionCode, codeSelectionString);
 			}
 		}
-		
-		GuardDetailExpressionProvider exprProvider = new RuntimeDetailExpressionProvider(ac);
-		exprProvider.setTransitionEventData(transitionEventData);
 
 		if (inherited) {
 			if (refined!=null) {
 				createActionCodeEditor(body, "&Action Code:",
 						refined.getAction(), refined,
 						FSMPackage.eINSTANCE.getTransitionBase_Action(),
-						null, s2m, m2s, true, true, false, null, exprProvider);
+						null, s2m, m2s, true, true, false, null, getExpressionProvider(refined, TRANSITION_BASE__ACTION));
 			}
 		}
 		else
 		{
 			createActionCodeEditor(body, "&Action Code:", trans.getAction(),
 					trans, FSMPackage.eINSTANCE.getTransitionBase_Action(), null,
-					s2m, m2s, true, true, false, null, exprProvider);
+					s2m, m2s, true, true, false, null, getExpressionProvider(trans, TRANSITION_BASE__ACTION));
 		}
 		
 		createMembersAndMessagesButtons(body);
@@ -268,7 +256,7 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 			});
 		}
 	}
-
+	
 	/* (non-Javadoc)
 	 * @see org.eclipse.etrice.ui.common.dialogs.AbstractPropertyDialog#updateValidationFeedback(boolean)
 	 */
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/ProviderDispatcher.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/ProviderDispatcher.java
deleted file mode 100644
index 340298044..000000000
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/ProviderDispatcher.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 protos software gmbh (http://www.protos.de).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * CONTRIBUTORS:
- * 		Henrik Rentz-Reichert (initial contribution)
- * 
- *******************************************************************************/
-
-package org.eclipse.etrice.ui.behavior.support;
-
-import org.eclipse.etrice.ui.behavior.Activator;
-import org.eclipse.etrice.ui.behavior.fsm.support.AbstractFSMProviderDispatcher;
-import org.eclipse.graphiti.dt.IDiagramTypeProvider;
-
-import com.google.inject.Injector;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class ProviderDispatcher extends AbstractFSMProviderDispatcher {
-
-
-	/**
-	 * @param dtp
-	 */
-	public ProviderDispatcher(IDiagramTypeProvider dtp) {
-		super(dtp);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.etrice.ui.behavior.fsm.provider.IInjectorProvider#getInjector()
-	 */
-	@Override
-	public Injector getInjector() {
-		return Activator.getDefault().getInjector();
-	}
-
-}
diff --git a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/SupportUtil.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/SupportUtil.java
index f4bea3ecb..d18fc5b9e 100644
--- a/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/SupportUtil.java
+++ b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/support/SupportUtil.java
@@ -13,7 +13,7 @@ import org.eclipse.etrice.core.naming.RoomNameProvider;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.util.RoomHelpers;
 import org.eclipse.etrice.core.ui.RoomUiModule;
-import org.eclipse.etrice.ui.behavior.fsm.support.FSMSupportUtil;
+import org.eclipse.etrice.ui.behavior.fsm.support.util.FSMSupportUtil;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.services.Graphiti;
 
diff --git a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/commands/UpdateCommand.java b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/commands/UpdateCommand.java
index c96378159..4e7837b3d 100644
--- a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/commands/UpdateCommand.java
+++ b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/commands/UpdateCommand.java
@@ -10,9 +10,10 @@ package org.eclipse.etrice.ui.common.base.commands;
 
 import org.eclipse.emf.transaction.RecordingCommand;
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
+import org.eclipse.graphiti.dt.IDiagramTypeProvider;
 import org.eclipse.graphiti.features.context.impl.UpdateContext;
-import org.eclipse.graphiti.features.impl.AbstractUpdateFeature;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
+import org.eclipse.graphiti.ui.services.GraphitiUi;
 
 /**
  * @author Henrik Rentz-Reichert - initial contribution and API
@@ -20,26 +21,26 @@ import org.eclipse.graphiti.mm.pictograms.Diagram;
  */
 public class UpdateCommand extends RecordingCommand {
 
-	private Diagram diagram;
-	private AbstractUpdateFeature feature;
+	private IDiagramTypeProvider dtp;
 
-	public UpdateCommand(Diagram diag, TransactionalEditingDomain domain, AbstractUpdateFeature feature) {
-		super(domain);
-		this.feature = feature;
+	public UpdateCommand(String providerId, Diagram diagram, TransactionalEditingDomain editingDomain) {
+		super(editingDomain);
+		
+		dtp = GraphitiUi.getExtensionManager().createDiagramTypeProvider(diagram, providerId); //$NON-NLS-1$
 	}
 
 	public boolean updateNeeded() {
-		UpdateContext context = new UpdateContext(diagram);
-		return feature.updateNeeded(context).toBoolean();
+		UpdateContext ctx = new UpdateContext(dtp.getDiagram());
+		return dtp.getFeatureProvider().getUpdateFeature(ctx).updateNeeded(ctx).toBoolean();
 	}
 	
 	/* (non-Javadoc)
 	 * @see org.eclipse.emf.transaction.RecordingCommand#doExecute()
 	 */
 	@Override
-	protected void doExecute() {
-		UpdateContext context = new UpdateContext(diagram);
-		feature.update(context);
+	protected void doExecute() {	
+		UpdateContext ctx = new UpdateContext(dtp.getDiagram());
+		dtp.getFeatureProvider().getUpdateFeature(ctx).update(ctx);
 	}
 
 }
diff --git a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/editor/SuperClassListener.java b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/editor/SuperClassListener.java
index 61cac5f7d..20741c198 100644
--- a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/editor/SuperClassListener.java
+++ b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/editor/SuperClassListener.java
@@ -39,32 +39,34 @@ public class SuperClassListener implements IPartListener, ResourceSetListener, I
 	private List<TransactionalEditingDomain> domains;
 	private List<IXtextDocument> xtextDocuments;
 	private boolean changeInSuperClass;
-	
+
 	public SuperClassListener(DiagramEditorBase diagramEditor, Object editorClass) {
 		this.diagramEditor = diagramEditor;
 		this.editorClass = editorClass;
 		domains = new ArrayList<TransactionalEditingDomain>();
 		xtextDocuments = new ArrayList<IXtextDocument>();
 		changeInSuperClass = false;
-		
-		assert(editorClass instanceof Class) : "Class expected";
+
+		assert (editorClass instanceof Class) : "Class expected";
 	}
-	
+
 	public boolean isChangeInSuperClass() {
 		return changeInSuperClass;
 	}
 
-	public void dispose(){
-		for(TransactionalEditingDomain domain : domains){
-			if(domain != null)
+	public void dispose() {
+		for (TransactionalEditingDomain domain : domains) {
+			if (domain != null)
 				domain.removeResourceSetListener(this);
 		}
-		for(IXtextDocument document : xtextDocuments){
-			if(document != null)
+		for (IXtextDocument document : xtextDocuments) {
+			if (document != null)
 				document.removeModelListener(this);
 		}
+		domains.clear();
+		xtextDocuments.clear();
 	}
-	
+
 	// ---
 	// IPartListener
 	// ---
@@ -81,18 +83,22 @@ public class SuperClassListener implements IPartListener, ResourceSetListener, I
 
 	@Override
 	public void partClosed(IWorkbenchPart part) {
-		if(part instanceof DiagramEditorBase){
-			DiagramEditorBase editor = (DiagramEditorBase)part;
+		if (part == diagramEditor) {
+			dispose();
+			return;
+		}
+
+		if (part instanceof DiagramEditorBase) {
+			DiagramEditorBase editor = (DiagramEditorBase) part;
 			TransactionalEditingDomain toRemove = editor.getEditingDomain();
-			if(toRemove != null){
+			if (toRemove != null) {
 				toRemove.removeResourceSetListener(this);
 				domains.remove(toRemove);
 			}
 		}
-		
-		if (((Class<?>)editorClass).isInstance(part)) {
+		if (((Class<?>) editorClass).isInstance(part)) {
 			IXtextDocument toRemove = ((XtextEditor) part).getDocument();
-			if(toRemove != null){
+			if (toRemove != null) {
 				toRemove.removeModelListener(this);
 				xtextDocuments.remove(toRemove);
 			}
@@ -101,43 +107,43 @@ public class SuperClassListener implements IPartListener, ResourceSetListener, I
 
 	@Override
 	public void partDeactivated(IWorkbenchPart part) {
-		if(part == diagramEditor)
+		if (part == diagramEditor)
 			changeInSuperClass = false;
 	}
 
 	@Override
 	public void partOpened(IWorkbenchPart part) {
 		// initial
-		if(part==diagramEditor){
+		if (part == diagramEditor) {
 			IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
 			for (IEditorReference editorRef : activePage.getEditorReferences()) {
 				IEditorPart editor = editorRef.getEditor(false);
-				if (editor != null && editor!=diagramEditor) 
+				if (editor != null && editor != diagramEditor)
 					partOpened(editor);
 			}
 			return;
 		}
-		
-		if(part instanceof DiagramEditorBase){
-			DiagramEditorBase editor = (DiagramEditorBase)part;
+
+		if (part instanceof DiagramEditorBase) {
+			DiagramEditorBase editor = (DiagramEditorBase) part;
 			TransactionalEditingDomain domain = editor.getEditingDomain();
-			if(!domains.contains(domain) && diagramEditor.registerSuperClassListener(editor)){
+			if (!domains.contains(domain) && diagramEditor.registerSuperClassListener(editor)) {
 				domain.addResourceSetListener(this);
 				domains.add(domain);
 			}
 		}
-		
-		if (((Class<?>)editorClass).isInstance(part)) {
+
+		if (((Class<?>) editorClass).isInstance(part)) {
 			XtextEditor editor = (XtextEditor) part;
 			IXtextDocument document = editor.getDocument();
-						
-			if(!xtextDocuments.contains(document) && diagramEditor.registerSuperClassListener(editor)){
+
+			if (!xtextDocuments.contains(document) && diagramEditor.registerSuperClassListener(editor)) {
 				editor.getDocument().addModelListener(this);
 				xtextDocuments.add(document);
 			}
 		}
 	}
-	
+
 	// ---
 	// ResourceSetListener
 	// ---
@@ -148,8 +154,7 @@ public class SuperClassListener implements IPartListener, ResourceSetListener, I
 	}
 
 	@Override
-	public Command transactionAboutToCommit(ResourceSetChangeEvent event)
-			throws RollbackException {
+	public Command transactionAboutToCommit(ResourceSetChangeEvent event) throws RollbackException {
 		return null;
 	}
 
@@ -173,7 +178,7 @@ public class SuperClassListener implements IPartListener, ResourceSetListener, I
 	public boolean isPostcommitOnly() {
 		return true;
 	}
-	
+
 	// ---
 	// IXtextModelListener
 	// ---
diff --git a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/support/DiagramAccessBase.java b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/support/DiagramAccessBase.java
index d380b3c07..00cab7af3 100644
--- a/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/support/DiagramAccessBase.java
+++ b/plugins/org.eclipse.etrice.ui.common.base/src/org/eclipse/etrice/ui/common/base/support/DiagramAccessBase.java
@@ -59,23 +59,30 @@ public abstract class DiagramAccessBase {
 	@Inject
 	private IResourceSetProvider resourceSetProvider;
 	
-	/**
-	 * 
-	 */
 	public DiagramAccessBase() {
 		super();
 		injectMembers();
 	}
+	
+	/**
+	 *  Load diagram based on rootObjects resource URI
+	 */
+	public Diagram getDiagram(EObject rootObject){
+		ResourceSet rs = newResourceSet(EcoreUtil.getURI(rootObject));
+		
+		return getDiagram(rootObject, rs);
+	}
 
-	public Diagram getDiagram(EObject rootObject) {
+	/**
+	 * Load diagram based on rootObjects resource URI into given resourceSet
+	 */
+	public Diagram getDiagram(EObject rootObject, ResourceSet rs) {
 		Resource resource = rootObject.eResource();
 		if (resource==null)
 			return null;
 		
 		URI uri = resource.getURI();
 		
-		ResourceSet rs = newResourceSet(uri);
-		
 		URI diagURI = null;
 		boolean exists = false;
 		if (uri.isPlatformResource()) {
@@ -144,33 +151,34 @@ public abstract class DiagramAccessBase {
 	}
 
 	private ResourceSet newResourceSet(URI uri) {
-		ResourceSet rs;
 		if (uri.isPlatformResource()) {
 			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(uri.toPlatformString(true)));
 			IProject project = file.getProject();
-			rs = resourceSetProvider.get(project);
-		}
-		else {
-			rs = new XtextResourceSet();
+			return resourceSetProvider.get(project);
 		}
-		return rs;
+		
+		return new XtextResourceSet();
 	}
 	
 	private void populateDiagram(EObject rootObject, Diagram diagram) {
-		ResourceSet rs = newResourceSet(rootObject.eResource().getURI());
+		ResourceSet rs = diagram.eResource().getResourceSet();
+		
+		// IMPORTANT STEP: this resolves the object and creates a new resource in the resource set
+		URI boUri = EcoreUtil.getURI(rootObject);
+		rootObject = rs.getEObject(boUri, true);
 		
+		boolean editingDomainOwner = false;
 		TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(rs);
 		if (editingDomain == null) {
 			// Not yet existing, create one
 			editingDomain = TransactionalEditingDomain.Factory.INSTANCE.createEditingDomain(rs);
+			editingDomainOwner = true;
 		}
-	
-		// IMPORTANT STEP: this resolves the object and creates a new resource in the resource set
-		URI boUri = EcoreUtil.getURI(rootObject);
-		rootObject = editingDomain.getResourceSet().getEObject(boUri, true);
 		
 		editingDomain.getCommandStack().execute(getInitialCommand(rootObject, diagram, editingDomain));
-		editingDomain.dispose();
+		if(editingDomainOwner){
+			editingDomain.dispose();
+		}
 	}
 
 	/**
@@ -178,11 +186,13 @@ public abstract class DiagramAccessBase {
 	 */
 	private void updateDiagram(Diagram diagram, boolean doSave) {
 		ResourceSet rs = diagram.eResource().getResourceSet();
+		boolean editingDomainOwner = false;
 		TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(rs);
 		try {
 			if (editingDomain == null) {
 				// Not yet existing, create one and start a write transaction
 				editingDomain = TransactionalEditingDomain.Factory.INSTANCE.createEditingDomain(rs);
+				editingDomainOwner = true;
 				((TransactionalEditingDomainImpl)editingDomain).startTransaction(false, null);
 			}
 			
@@ -202,7 +212,9 @@ public abstract class DiagramAccessBase {
 		catch (InterruptedException e) {
 		}
 		
-		editingDomain.dispose();
+		if(editingDomainOwner){
+			editingDomain.dispose();
+		}
 	}
 
 	public DiagramEditorBase findDiagramEditor(EObject rootObject) {
diff --git a/plugins/org.eclipse.etrice.ui.runtime/.gitignore b/plugins/org.eclipse.etrice.ui.runtime/.gitignore
index 09da981ec..a8b968b6f 100644
--- a/plugins/org.eclipse.etrice.ui.runtime/.gitignore
+++ b/plugins/org.eclipse.etrice.ui.runtime/.gitignore
@@ -1,2 +1,2 @@
-/bin/
-contents/
\ No newline at end of file
+bin
+contents
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.c.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.c.zip
new file mode 100644
index 000000000..ed6173b13
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.c.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.java.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.java.zip
new file mode 100644
index 000000000..2f53cd81c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.examples.java.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.c.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.c.zip
new file mode 100644
index 000000000..ed21c611c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.c.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.cpp.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.cpp.zip
new file mode 100644
index 000000000..16d7b7383
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.cpp.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.java.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.java.zip
new file mode 100644
index 000000000..2b1bca998
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.modellib.java.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.c.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.c.zip
new file mode 100644
index 000000000..f777ea6f2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.c.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.cpp.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.cpp.zip
new file mode 100644
index 000000000..289c7c229
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.cpp.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.java.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.java.zip
new file mode 100644
index 000000000..39f115a2f
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.runtime.java.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.c.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.c.zip
new file mode 100644
index 000000000..f52bcd082
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.c.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.cpp.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.cpp.zip
new file mode 100644
index 000000000..1a5323be7
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.template.cpp.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.c.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.c.zip
new file mode 100644
index 000000000..974fdae39
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.c.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.cpp.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.cpp.zip
new file mode 100644
index 000000000..6b180eb50
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.cpp.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.java.zip b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.java.zip
new file mode 100644
index 000000000..fa6bf2b31
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.java.zip
diff --git a/plugins/org.eclipse.etrice.ui.runtime/create_contents.xml b/plugins/org.eclipse.etrice.ui.runtime/create_contents.xml
index 2ef2e5f96..25f2d4910 100644
--- a/plugins/org.eclipse.etrice.ui.runtime/create_contents.xml
+++ b/plugins/org.eclipse.etrice.ui.runtime/create_contents.xml
@@ -15,7 +15,7 @@
 		<attribute name="source" default="default" />
 		<sequential>
 			<delete file="${target}/@{name}.zip" />
-			<zip destfile="${target}/@{name}.zip" basedir="@{source}/@{name}" excludes="pom.xml,bin/**,Debug/**,Release/**,*.cspec,jgen_*,target/**,WindowsMinGW/**,LinuxPosix/**"  />
+			<zip destfile="${target}/@{name}.zip" basedir="@{source}/@{name}" excludes="pom.xml,bin/**,Debug/**,Release/**,*.cspec,jgen_*,target/**,WindowsMinGW/**,LinuxPosix/**,build/**"  />
 			<echo message="zipped ${target}/@{name}.zip" />
 		</sequential>
 	</macrodef>